diff --git a/es2panda/CMakeLists.txt b/es2panda/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..58cbe2c8239a7cbb78c70a5dbc43b452fb6f2587
--- /dev/null
+++ b/es2panda/CMakeLists.txt
@@ -0,0 +1,337 @@
+# Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+cmake_minimum_required (VERSION 3.5.0)
+
+project (es2panda)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+set(OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/out)
+set(GENERATED_DIR ${OUTPUT_DIR}/gen)
+set(GENERATED_STAMP ${OUTPUT_DIR}/gen_dir.stamp)
+add_custom_target(es2panda-gen)
+
+add_custom_command(
+  OUTPUT ${GENERATED_STAMP}
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPUT_DIR}
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${GENERATED_DIR}
+  COMMAND ${CMAKE_COMMAND} -E touch ${GENERATED_STAMP}
+)
+
+set(TEMPLATES
+  isa.h.erb
+  formats.h.erb
+)
+
+panda_isa_gen(
+  TEMPLATES ${TEMPLATES}
+  SOURCE ${CMAKE_CURRENT_LIST_DIR}/compiler/templates
+  DESTINATION ${GENERATED_DIR}
+  EXTRA_DEPENDENCIES ${GENERATED_STAMP}
+)
+
+add_dependencies(es2panda-gen isa_gen_es2panda)
+
+function(gen_keywords TEMPLATE OUT_DIR)
+  set(TEMPLATE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/lexer/templates/${TEMPLATE})
+
+  string(REGEX REPLACE "\.erb$" "" NAME ${TEMPLATE})
+  string(REPLACE "\." "_" CUSTOM_TARGET ${NAME})
+  string(REPLACE "/" "_" CUSTOM_TARGET ${CUSTOM_TARGET})
+  set(CUSTOM_TARGET "panda_es2panda_parser_gen_${CUSTOM_TARGET}")
+
+  set(OUT_FILE ${OUT_DIR}/${NAME})
+  set(GENERATOR ${CMAKE_CURRENT_SOURCE_DIR}/lexer/scripts/keywords.rb)
+
+  add_custom_command(OUTPUT ${OUT_FILE}
+    COMMAND ruby ${GENERATOR} ${TEMPLATE_FILE} ${OUT_FILE}
+    DEPENDS ${GENERATED_STAMP} ${GENERATOR} ${TEMPLATE_FILE}
+  )
+
+  add_custom_target(${CUSTOM_TARGET} DEPENDS ${OUT_FILE})
+  add_dependencies(es2panda-gen ${CUSTOM_TARGET})
+endfunction()
+
+gen_keywords(keywords.h.erb ${GENERATED_DIR})
+gen_keywords(keywordsMap.h.erb ${GENERATED_DIR})
+
+set(ES2PANDA_LIB_SRC
+  es2panda.cpp
+  binder/binder.cpp
+  binder/declaration.cpp
+  binder/scope.cpp
+  binder/variable.cpp
+  compiler/base/catchTable.cpp
+  compiler/base/condition.cpp
+  compiler/base/destructuring.cpp
+  compiler/base/hoisting.cpp
+  compiler/base/iterators.cpp
+  compiler/base/lexenv.cpp
+  compiler/base/literals.cpp
+  compiler/base/lreference.cpp
+  compiler/core/compileQueue.cpp
+  compiler/core/compilerContext.cpp
+  compiler/core/compilerImpl.cpp
+  compiler/core/dynamicContext.cpp
+  compiler/core/emitter.cpp
+  compiler/core/envScope.cpp
+  compiler/core/function.cpp
+  compiler/core/inlineCache.cpp
+  compiler/core/labelTarget.cpp
+  compiler/core/moduleContext.cpp
+  compiler/core/pandagen.cpp
+  compiler/core/regAllocator.cpp
+  compiler/core/regScope.cpp
+  compiler/core/switchBuilder.cpp
+  compiler/debugger/debuginfoDumper.cpp
+  compiler/function/asyncFunctionBuilder.cpp
+  compiler/function/asyncGeneratorFunctionBuilder.cpp
+  compiler/function/functionBuilder.cpp
+  compiler/function/generatorFunctionBuilder.cpp
+  ir/astDump.cpp
+  ir/base/catchClause.cpp
+  ir/base/classDefinition.cpp
+  ir/base/classProperty.cpp
+  ir/base/decorator.cpp
+  ir/base/metaProperty.cpp
+  ir/base/methodDefinition.cpp
+  ir/base/property.cpp
+  ir/base/scriptFunction.cpp
+  ir/base/spreadElement.cpp
+  ir/base/templateElement.cpp
+  ir/expression.cpp
+  ir/expressions/arrayExpression.cpp
+  ir/expressions/arrowFunctionExpression.cpp
+  ir/expressions/assignmentExpression.cpp
+  ir/expressions/awaitExpression.cpp
+  ir/expressions/binaryExpression.cpp
+  ir/expressions/callExpression.cpp
+  ir/expressions/chainExpression.cpp
+  ir/expressions/classExpression.cpp
+  ir/expressions/conditionalExpression.cpp
+  ir/expressions/functionExpression.cpp
+  ir/expressions/identifier.cpp
+  ir/expressions/importExpression.cpp
+  ir/expressions/literal.cpp
+  ir/expressions/literals/bigIntLiteral.cpp
+  ir/expressions/literals/booleanLiteral.cpp
+  ir/expressions/literals/nullLiteral.cpp
+  ir/expressions/literals/numberLiteral.cpp
+  ir/expressions/literals/regExpLiteral.cpp
+  ir/expressions/literals/stringLiteral.cpp
+  ir/expressions/literals/taggedLiteral.cpp
+  ir/expressions/memberExpression.cpp
+  ir/expressions/newExpression.cpp
+  ir/expressions/objectExpression.cpp
+  ir/expressions/omittedExpression.cpp
+  ir/expressions/sequenceExpression.cpp
+  ir/expressions/superExpression.cpp
+  ir/expressions/taggedTemplateExpression.cpp
+  ir/expressions/templateLiteral.cpp
+  ir/expressions/thisExpression.cpp
+  ir/expressions/unaryExpression.cpp
+  ir/expressions/updateExpression.cpp
+  ir/expressions/yieldExpression.cpp
+  ir/module/exportAllDeclaration.cpp
+  ir/module/exportDefaultDeclaration.cpp
+  ir/module/exportNamedDeclaration.cpp
+  ir/module/exportSpecifier.cpp
+  ir/module/importDeclaration.cpp
+  ir/module/importDefaultSpecifier.cpp
+  ir/module/importNamespaceSpecifier.cpp
+  ir/module/importSpecifier.cpp
+  ir/statement.cpp
+  ir/statements/blockStatement.cpp
+  ir/statements/breakStatement.cpp
+  ir/statements/classDeclaration.cpp
+  ir/statements/continueStatement.cpp
+  ir/statements/debuggerStatement.cpp
+  ir/statements/doWhileStatement.cpp
+  ir/statements/emptyStatement.cpp
+  ir/statements/expressionStatement.cpp
+  ir/statements/forInStatement.cpp
+  ir/statements/forOfStatement.cpp
+  ir/statements/forUpdateStatement.cpp
+  ir/statements/functionDeclaration.cpp
+  ir/statements/ifStatement.cpp
+  ir/statements/labelledStatement.cpp
+  ir/statements/loopStatement.cpp
+  ir/statements/returnStatement.cpp
+  ir/statements/switchCaseStatement.cpp
+  ir/statements/switchStatement.cpp
+  ir/statements/throwStatement.cpp
+  ir/statements/tryStatement.cpp
+  ir/statements/variableDeclaration.cpp
+  ir/statements/variableDeclarator.cpp
+  ir/statements/whileStatement.cpp
+  ir/ts/tsAnyKeyword.cpp
+  ir/ts/tsArrayType.cpp
+  ir/ts/tsAsExpression.cpp
+  ir/ts/tsBigintKeyword.cpp
+  ir/ts/tsBooleanKeyword.cpp
+  ir/ts/tsClassImplements.cpp
+  ir/ts/tsConditionalType.cpp
+  ir/ts/tsConstructorType.cpp
+  ir/ts/tsEnumDeclaration.cpp
+  ir/ts/tsEnumMember.cpp
+  ir/ts/tsExternalModuleReference.cpp
+  ir/ts/tsFunctionType.cpp
+  ir/ts/tsImportEqualsDeclaration.cpp
+  ir/ts/tsImportType.cpp
+  ir/ts/tsIndexSignature.cpp
+  ir/ts/tsIndexedAccessType.cpp
+  ir/ts/tsInferType.cpp
+  ir/ts/tsInterfaceBody.cpp
+  ir/ts/tsInterfaceDeclaration.cpp
+  ir/ts/tsInterfaceHeritage.cpp
+  ir/ts/tsIntersectionType.cpp
+  ir/ts/tsLiteralType.cpp
+  ir/ts/tsMappedType.cpp
+  ir/ts/tsMethodSignature.cpp
+  ir/ts/tsModuleBlock.cpp
+  ir/ts/tsModuleDeclaration.cpp
+  ir/ts/tsNamedTupleMember.cpp
+  ir/ts/tsNeverKeyword.cpp
+  ir/ts/tsNonNullExpression.cpp
+  ir/ts/tsNullKeyword.cpp
+  ir/ts/tsNumberKeyword.cpp
+  ir/ts/tsObjectKeyword.cpp
+  ir/ts/tsParameterProperty.cpp
+  ir/ts/tsParenthesizedType.cpp
+  ir/ts/tsPrivateIdentifier.cpp
+  ir/ts/tsPropertySignature.cpp
+  ir/ts/tsQualifiedName.cpp
+  ir/ts/tsSignatureDeclaration.cpp
+  ir/ts/tsStringKeyword.cpp
+  ir/ts/tsThisType.cpp
+  ir/ts/tsTupleType.cpp
+  ir/ts/tsTypeAliasDeclaration.cpp
+  ir/ts/tsTypeAssertion.cpp
+  ir/ts/tsTypeLiteral.cpp
+  ir/ts/tsTypeOperator.cpp
+  ir/ts/tsTypeParameter.cpp
+  ir/ts/tsTypeParameterDeclaration.cpp
+  ir/ts/tsTypeParameterInstantiation.cpp
+  ir/ts/tsTypePredicate.cpp
+  ir/ts/tsTypeQuery.cpp
+  ir/ts/tsTypeReference.cpp
+  ir/ts/tsUndefinedKeyword.cpp
+  ir/ts/tsUnionType.cpp
+  ir/ts/tsUnknownKeyword.cpp
+  ir/ts/tsVoidKeyword.cpp
+  lexer/keywordsUtil.cpp
+  lexer/lexer.cpp
+  lexer/regexp/regexp.cpp
+  lexer/token/sourceLocation.cpp
+  lexer/token/token.cpp
+  parser/context/parserContext.cpp
+  parser/expressionParser.cpp
+  parser/parserImpl.cpp
+  parser/program/program.cpp
+  parser/statementParser.cpp
+  typescript/checker.cpp
+  typescript/core/binaryLikeExpression.cpp
+  typescript/core/destructuring.cpp
+  typescript/core/function.cpp
+  typescript/core/generics.cpp
+  typescript/core/helpers.cpp
+  typescript/core/object.cpp
+  typescript/core/typeCreation.cpp
+  typescript/core/typeElaboration.cpp
+  typescript/core/typeRelation.cpp
+  typescript/core/util.cpp
+  typescript/types/anyType.cpp
+  typescript/types/arrayType.cpp
+  typescript/types/bigintLiteralType.cpp
+  typescript/types/bigintType.cpp
+  typescript/types/booleanLiteralType.cpp
+  typescript/types/booleanType.cpp
+  typescript/types/constructorType.cpp
+  typescript/types/enumLiteralType.cpp
+  typescript/types/enumType.cpp
+  typescript/types/functionType.cpp
+  typescript/types/globalTypesHolder.cpp
+  typescript/types/indexInfo.cpp
+  typescript/types/interfaceType.cpp
+  typescript/types/neverType.cpp
+  typescript/types/nonPrimitiveType.cpp
+  typescript/types/nullType.cpp
+  typescript/types/numberLiteralType.cpp
+  typescript/types/numberType.cpp
+  typescript/types/objectDescriptor.cpp
+  typescript/types/objectLiteralType.cpp
+  typescript/types/objectType.cpp
+  typescript/types/signature.cpp
+  typescript/types/stringLiteralType.cpp
+  typescript/types/stringType.cpp
+  typescript/types/tupleType.cpp
+  typescript/types/type.cpp
+  typescript/types/typeParameter.cpp
+  typescript/types/typeReference.cpp
+  typescript/types/typeRelation.cpp
+  typescript/types/undefinedType.cpp
+  typescript/types/unionType.cpp
+  typescript/types/unknownType.cpp
+  typescript/types/voidType.cpp
+  util/bitset.cpp
+  util/helpers.cpp
+  util/ustring.cpp
+)
+
+add_library(es2panda-lib ${PANDA_DEFAULT_LIB_TYPE} ${ES2PANDA_LIB_SRC})
+add_dependencies(es2panda-lib es2panda-gen)
+
+set(ICU_INCLUDE_DIRS
+    ${PANDA_THIRD_PARTY_SOURCES_DIR}/icu/icu4c/source/common
+    ${PANDA_THIRD_PARTY_SOURCES_DIR}/icu/icu4c/source/i18n
+    ${PANDA_THIRD_PARTY_SOURCES_DIR}/icu/icu4c/source
+)
+
+target_include_directories(es2panda-lib
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+  PRIVATE ${OUTPUT_DIR}
+  PRIVATE ${ICU_INCLUDE_DIRS}
+)
+
+target_compile_options(es2panda-lib
+  PRIVATE -fexceptions -Werror=shadow
+)
+
+target_link_libraries(es2panda-lib
+  PUBLIC arkbase hmicuuc.z
+  PRIVATE arkassembler
+)
+
+if (PANDA_FUZZILLI)
+  target_compile_options(es2panda-lib
+      PRIVATE -fPIC
+  )
+endif()
+
+panda_add_sanitizers(TARGET es2panda-lib SANITIZERS ${PANDA_SANITIZERS_LIST})
+panda_add_to_clang_tidy(TARGET es2panda-lib CHECKS
+    "-modernize-use-trailing-return-type"
+    "-llvmlibc-restrict-system-libc-headers"
+    "-llvmlibc-callee-namespace"
+    "-cert-dcl21-cpp"
+    "-cppcoreguidelines-macro-usage"
+    "-cppcoreguidelines-pro-bounds-pointer-arithmetic"
+    "-fuchsia-default-arguments-calls"
+    "-fuchsia-default-arguments-declarations"
+    "-readability-implicit-bool-conversion"
+    "-misc-non-private-member-variables-in-classes"
+    "-hicpp-signed-bitwise"
+    "-altera-struct-pack-align"
+)
+
+add_subdirectory(aot)
diff --git a/es2panda/README.md b/es2panda/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..43a3d5500db85b11cc4cf8d434e6e7b577e043c8
--- /dev/null
+++ b/es2panda/README.md
@@ -0,0 +1,43 @@
+# Es2panda
+
+All in one JavaScript/TypeScript parser and compiler.
+
+## Usage
+```sh
+es2panda [OPTIONS] [input file] -- [arguments]
+```
+
+## Optional arguments
+ - `--debug-info`: Compile with debug info
+ - `--dump-assembly`: Dump pandasm
+ - `--dump-ast`: Dump the parsed AST
+ - `--dump-debug-info`: Dump debug info
+ - `--dump-size-stat`: Dump binary size statistics
+ - `--extension`: Parse the input as the given extension (options: js | ts | as)
+ - `--module`: Parse the input as module
+ - `--opt-level`: Compiler optimization level (options: 0 | 1 | 2)
+ - `--output`: Compiler binary output (.abc)
+ - `--parse-only`: Parse the input only
+ - `--strict`: Parse the input in strict mode
+
+## Tail arguments
+ - `input`: input file
+
+## Running the tests
+```sh
+pip install tqdm
+```
+```sh
+python3 test/runner.py [OPTIONS] [build_directory]
+```
+
+### Optional arguments
+ - `--regression`: Run regression tests
+ - `--test262`: Run test262
+ - `--no-progress`: Don't show progress bar
+
+### Tail arguments
+ - `build_directory`: Path to panda build directory
+
+### Skip list
+Skip list for the runtime: `test/test262skiplist.txt, test/test262skiplist-long.txt`.
diff --git a/es2panda/aot/CMakeLists.txt b/es2panda/aot/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4c39424742a97aa185d5510950319a0d7cf48b9
--- /dev/null
+++ b/es2panda/aot/CMakeLists.txt
@@ -0,0 +1,47 @@
+# Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(ES2PANDA_AOT_SRC
+  options.cpp
+  main.cpp
+)
+
+panda_add_executable(es2panda ${ES2PANDA_AOT_SRC})
+target_link_libraries(es2panda es2panda-lib arkassembler arkbytecodeopt)
+target_include_directories(es2panda PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
+if (PANDA_FUZZILLI)
+    target_compile_options(es2panda
+        PRIVATE -fPIC
+    )
+endif()
+
+target_compile_options(es2panda
+  PRIVATE -Werror=shadow
+)
+
+panda_add_sanitizers(TARGET es2panda SANITIZERS ${PANDA_SANITIZERS_LIST})
+panda_add_to_clang_tidy(TARGET es2panda CHECKS
+    "-modernize-use-trailing-return-type"
+    "-llvmlibc-restrict-system-libc-headers"
+    "-llvmlibc-callee-namespace"
+    "-cert-dcl21-cpp"
+    "-cppcoreguidelines-macro-usage"
+    "-cppcoreguidelines-pro-bounds-pointer-arithmetic"
+    "-fuchsia-default-arguments-calls"
+    "-fuchsia-default-arguments-declarations"
+    "-readability-implicit-bool-conversion"
+    "-misc-non-private-member-variables-in-classes"
+    "-hicpp-signed-bitwise"
+    "-altera-struct-pack-align"
+)
diff --git a/es2panda/aot/main.cpp b/es2panda/aot/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8dbd680977fa6e901ca1e41d7f6dbc8235458125
--- /dev/null
+++ b/es2panda/aot/main.cpp
@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <assembly-literals.h>
+#include <bytecode_optimizer/bytecodeopt_options.h>
+#include <bytecode_optimizer/optimize_bytecode.h>
+#include <mem/arena_allocator.h>
+#include <mem/pool_manager.h>
+#include <options.h>
+#include <plugins/ecmascript/es2panda/es2panda.h>
+
+#include <iostream>
+#include <memory>
+
+namespace panda::es2panda::aot {
+
+using mem::MemConfig;
+
+class MemManager {
+public:
+    explicit MemManager()
+    {
+        constexpr auto COMPILER_SIZE = 128_MB;
+
+        MemConfig::Initialize(0, 0, COMPILER_SIZE, 0);
+        PoolManager::Initialize(PoolType::MMAP);
+    }
+
+    NO_COPY_SEMANTIC(MemManager);
+    NO_MOVE_SEMANTIC(MemManager);
+
+    ~MemManager()
+    {
+        PoolManager::Finalize();
+        MemConfig::Finalize();
+    }
+};
+
+static int GenerateProgram(panda::pandasm::Program *prog, const std::string &output, int optLevel, bool dumpAsm,
+                           bool dumpSize)
+{
+    std::map<std::string, size_t> stat;
+    std::map<std::string, size_t> *statp = optLevel != 0 ? &stat : nullptr;
+    panda::pandasm::AsmEmitter::PandaFileToPandaAsmMaps maps {};
+    panda::pandasm::AsmEmitter::PandaFileToPandaAsmMaps *mapsp = optLevel != 0 ? &maps : nullptr;
+
+#ifdef PANDA_WITH_BYTECODE_OPTIMIZER
+    if (optLevel != 0) {
+        const uint32_t COMPONENT_MASK = panda::Logger::Component::ASSEMBLER |
+                                        panda::Logger::Component::BYTECODE_OPTIMIZER |
+                                        panda::Logger::Component::COMPILER;
+        panda::Logger::InitializeStdLogging(panda::Logger::Level::ERROR, COMPONENT_MASK);
+
+        if (!panda::pandasm::AsmEmitter::Emit(output, *prog, statp, mapsp, true)) {
+            return 1;
+        }
+
+        panda::bytecodeopt::options.SetOptLevel(optLevel);
+        panda::bytecodeopt::OptimizeBytecode(prog, mapsp, output, true, true);
+    }
+#endif
+
+    if (dumpAsm) {
+        es2panda::Compiler::DumpAsm(prog);
+    }
+
+    if (!panda::pandasm::AsmEmitter::Emit(output, *prog, statp, mapsp, true)) {
+        return 1;
+    }
+
+    if (dumpSize && optLevel != 0) {
+        size_t totalSize = 0;
+        std::cout << "Panda file size statistic:" << std::endl;
+        constexpr std::array<std::string_view, 2> INFO_STATS = {"instructions_number", "codesize"};
+
+        for (const auto &[name, size] : stat) {
+            if (find(INFO_STATS.begin(), INFO_STATS.end(), name) != INFO_STATS.end()) {
+                continue;
+            }
+            std::cout << name << " section: " << size << std::endl;
+            totalSize += size;
+        }
+
+        for (const auto &name : INFO_STATS) {
+            std::cout << name << ": " << stat.at(std::string(name)) << std::endl;
+        }
+
+        std::cout << "total: " << totalSize << std::endl;
+    }
+
+    return 0;
+}
+
+int Run(int argc, const char **argv)
+{
+    auto options = std::make_unique<Options>();
+
+    if (!options->Parse(argc, argv)) {
+        std::cerr << options->ErrorMsg() << std::endl;
+        return 1;
+    }
+
+    es2panda::Compiler compiler(options->Extension(), options->ThreadCount());
+    es2panda::SourceFile input(options->SourceFile(), options->ParserInput(), options->ParseModule());
+
+    auto *program = compiler.Compile(input, options->CompilerOptions());
+
+    if (!program) {
+        const auto &err = compiler.GetError();
+
+        if (err.Message().empty() && options->ParseOnly()) {
+            return 0;
+        }
+
+        std::cout << err.TypeString() << ": " << err.Message();
+        std::cout << " [" << options->SourceFile() << ":" << err.Line() << ":" << err.Col() << "]" << std::endl;
+
+        return err.ErrorCode();
+    }
+
+    GenerateProgram(program, options->CompilerOutput(), options->OptLevel(), options->CompilerOptions().dumpAsm,
+                    options->SizeStat());
+    delete program;
+
+    return 0;
+}
+
+}  // namespace panda::es2panda::aot
+
+int main(int argc, const char **argv)
+{
+    panda::es2panda::aot::MemManager mm;
+    return panda::es2panda::aot::Run(argc, argv);
+}
diff --git a/es2panda/aot/options.cpp b/es2panda/aot/options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9be3f001c5b1f2f8a6c5e7e5cd796649fe38f70d
--- /dev/null
+++ b/es2panda/aot/options.cpp
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "options.h"
+
+#include <utils/pandargs.h>
+
+#include <utility>
+
+namespace panda::es2panda::aot {
+
+template <class T>
+T BaseName(T const &path, T const &delims = "/")
+{
+    return path.substr(path.find_last_of(delims) + 1);
+}
+
+template <class T>
+T RemoveExtension(T const &filename)
+{
+    typename T::size_type const P(filename.find_last_of('.'));
+    return P > 0 && P != T::npos ? filename.substr(0, P) : filename;
+}
+
+// Options
+
+Options::Options() : argparser_(new panda::PandArgParser()) {}
+
+Options::~Options()
+{
+    delete argparser_;
+}
+
+bool Options::Parse(int argc, const char **argv)
+{
+    panda::PandArg<bool> opHelp("help", false, "Print this message and exit");
+
+    // parser
+    panda::PandArg<std::string> inputExtension("extension", "js",
+                                               "Parse the input as the given extension (options: js | ts | as)");
+    panda::PandArg<bool> opModule("module", false, "Parse the input as module");
+    panda::PandArg<bool> opParseOnly("parse-only", false, "Parse the input only");
+    panda::PandArg<bool> opDumpAst("dump-ast", false, "Dump the parsed AST");
+
+    // compiler
+    panda::PandArg<bool> opDumpAssembly("dump-assembly", false, "Dump pandasm");
+    panda::PandArg<bool> opDebugInfo("debug-info", false, "Compile with debug info");
+    panda::PandArg<bool> opDumpDebugInfo("dump-debug-info", false, "Dump debug info");
+    panda::PandArg<int> opOptLevel("opt-level", 0, "Compiler optimization level (options: 0 | 1 | 2)");
+    panda::PandArg<int> opThreadCount("thread", 0, "Number of worker theads");
+    panda::PandArg<bool> opSizeStat("dump-size-stat", false, "Dump size statistics");
+    panda::PandArg<std::string> outputFile("output", "", "Compiler binary output (.abc)");
+
+    // tail arguments
+    panda::PandArg<std::string> inputFile("input", "", "input file");
+
+    argparser_->Add(&opHelp);
+    argparser_->Add(&opModule);
+    argparser_->Add(&opDumpAst);
+    argparser_->Add(&opParseOnly);
+    argparser_->Add(&opDumpAssembly);
+    argparser_->Add(&opDebugInfo);
+    argparser_->Add(&opDumpDebugInfo);
+
+    argparser_->Add(&opOptLevel);
+    argparser_->Add(&opThreadCount);
+    argparser_->Add(&opSizeStat);
+
+    argparser_->Add(&inputExtension);
+    argparser_->Add(&outputFile);
+
+    argparser_->PushBackTail(&inputFile);
+    argparser_->EnableTail();
+    argparser_->EnableRemainder();
+
+    if (!argparser_->Parse(argc, argv) || inputFile.GetValue().empty() || opHelp.GetValue()) {
+        std::stringstream ss;
+
+        ss << argparser_->GetErrorString() << std::endl;
+        ss << "Usage: "
+           << "es2panda"
+           << " [OPTIONS] [input file] -- [arguments]" << std::endl;
+        ss << std::endl;
+        ss << "optional arguments:" << std::endl;
+        ss << argparser_->GetHelpString() << std::endl;
+
+        errorMsg_ = ss.str();
+        return false;
+    }
+
+    sourceFile_ = inputFile.GetValue();
+    std::ifstream inputStream(sourceFile_.c_str());
+
+    if (inputStream.fail()) {
+        errorMsg_ = "Failed to open file: ";
+        errorMsg_.append(sourceFile_);
+        return false;
+    }
+
+    std::stringstream ss;
+    ss << inputStream.rdbuf();
+    parserInput_ = ss.str();
+
+    sourceFile_ = BaseName(sourceFile_);
+
+    if (!outputFile.GetValue().empty()) {
+        compilerOutput_ = outputFile.GetValue();
+    } else {
+        compilerOutput_ = RemoveExtension(sourceFile_).append(".abc");
+    }
+
+    std::string extension = inputExtension.GetValue();
+
+    if (!extension.empty()) {
+        if (extension == "js") {
+            extension_ = es2panda::ScriptExtension::JS;
+        } else if (extension == "ts") {
+            extension_ = es2panda::ScriptExtension::TS;
+        } else if (extension == "as") {
+            extension_ = es2panda::ScriptExtension::AS;
+        } else {
+            errorMsg_ = "Invalid extension (available options: js, ts, as)";
+            return false;
+        }
+    }
+
+    optLevel_ = opOptLevel.GetValue();
+    threadCount_ = opThreadCount.GetValue();
+
+    if (opParseOnly.GetValue()) {
+        options_ |= OptionFlags::PARSE_ONLY;
+    }
+
+    if (opModule.GetValue()) {
+        options_ |= OptionFlags::PARSE_MODULE;
+    }
+
+    if (opSizeStat.GetValue()) {
+        options_ |= OptionFlags::SIZE_STAT;
+    }
+
+    compilerOptions_.dumpAsm = opDumpAssembly.GetValue();
+    compilerOptions_.dumpAst = opDumpAst.GetValue();
+    compilerOptions_.dumpDebugInfo = opDumpDebugInfo.GetValue();
+    compilerOptions_.isDebug = opDebugInfo.GetValue();
+    compilerOptions_.parseOnly = opParseOnly.GetValue();
+
+    return true;
+}
+
+}  // namespace panda::es2panda::aot
diff --git a/es2panda/aot/options.h b/es2panda/aot/options.h
new file mode 100644
index 0000000000000000000000000000000000000000..af8c8e3093a40394bd8679a28407a28d4dd16708
--- /dev/null
+++ b/es2panda/aot/options.h
@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_AOT_OPTIONS_H
+#define ES2PANDA_AOT_OPTIONS_H
+
+#include <macros.h>
+#include <plugins/ecmascript/es2panda/es2panda.h>
+
+#include <exception>
+#include <fstream>
+#include <iostream>
+
+namespace panda {
+class PandArgParser;
+class PandaArg;
+}  // namespace panda
+
+namespace panda::es2panda::aot {
+
+enum class OptionFlags {
+    DEFAULT = 0,
+    PARSE_ONLY = 1 << 1,
+    PARSE_MODULE = 1 << 2,
+    SIZE_STAT = 1 << 3,
+};
+
+inline std::underlying_type_t<OptionFlags> operator&(OptionFlags a, OptionFlags b)
+{
+    using utype = std::underlying_type_t<OptionFlags>;
+    /* NOLINTNEXTLINE(hicpp-signed-bitwise) */
+    return static_cast<utype>(static_cast<utype>(a) & static_cast<utype>(b));
+}
+
+inline OptionFlags &operator|=(OptionFlags &a, OptionFlags b)
+{
+    using utype = std::underlying_type_t<OptionFlags>;
+    /* NOLINTNEXTLINE(hicpp-signed-bitwise) */
+    return a = static_cast<OptionFlags>(static_cast<utype>(a) | static_cast<utype>(b));
+}
+
+class Options {
+public:
+    Options();
+    NO_COPY_SEMANTIC(Options);
+    NO_MOVE_SEMANTIC(Options);
+    ~Options();
+
+    bool Parse(int argc, const char **argv);
+
+    es2panda::ScriptExtension Extension() const
+    {
+        return extension_;
+    }
+
+    const es2panda::CompilerOptions &CompilerOptions() const
+    {
+        return compilerOptions_;
+    }
+
+    const std::string &ParserInput() const
+    {
+        return parserInput_;
+    }
+
+    const std::string &CompilerOutput() const
+    {
+        return compilerOutput_;
+    }
+
+    const std::string &SourceFile() const
+    {
+        return sourceFile_;
+    }
+
+    const std::string &ErrorMsg() const
+    {
+        return errorMsg_;
+    }
+
+    int OptLevel() const
+    {
+        return optLevel_;
+    }
+
+    int ThreadCount() const
+    {
+        return threadCount_;
+    }
+
+    bool ParseModule() const
+    {
+        return (options_ & OptionFlags::PARSE_MODULE) != 0;
+    }
+
+    bool ParseOnly() const
+    {
+        return (options_ & OptionFlags::PARSE_ONLY) != 0;
+    }
+
+    bool SizeStat() const
+    {
+        return (options_ & OptionFlags::SIZE_STAT) != 0;
+    }
+
+private:
+    es2panda::ScriptExtension extension_ {es2panda::ScriptExtension::JS};
+    es2panda::CompilerOptions compilerOptions_ {};
+    OptionFlags options_ {OptionFlags::DEFAULT};
+    panda::PandArgParser *argparser_;
+    std::string parserInput_;
+    std::string compilerOutput_;
+    std::string result_;
+    std::string sourceFile_;
+    std::string errorMsg_;
+    int optLevel_ {0};
+    int threadCount_ {0};
+};
+
+}  // namespace panda::es2panda::aot
+
+#endif  // AOT_OPTIONS_H
diff --git a/es2panda/binder/binder.cpp b/es2panda/binder/binder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d2a8b2ad397c8be9b3a5a17ca306bd6354d2d199
--- /dev/null
+++ b/es2panda/binder/binder.cpp
@@ -0,0 +1,509 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "binder.h"
+
+#include <util/helpers.h>
+#include <binder/scope.h>
+#include <binder/tsBinding.h>
+#include <es2panda.h>
+#include <ir/astNode.h>
+#include <ir/base/catchClause.h>
+#include <ir/base/classDefinition.h>
+#include <ir/base/methodDefinition.h>
+#include <ir/base/property.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/statements/blockStatement.h>
+#include <ir/statements/doWhileStatement.h>
+#include <ir/statements/forInStatement.h>
+#include <ir/statements/forOfStatement.h>
+#include <ir/statements/forUpdateStatement.h>
+#include <ir/statements/ifStatement.h>
+#include <ir/statements/switchStatement.h>
+#include <ir/statements/variableDeclaration.h>
+#include <ir/statements/variableDeclarator.h>
+#include <ir/statements/whileStatement.h>
+
+namespace panda::es2panda::binder {
+void Binder::InitTopScope()
+{
+    if (program_->Kind() == parser::ScriptKind::MODULE) {
+        topScope_ = Allocator()->New<ModuleScope>(Allocator());
+    } else {
+        topScope_ = Allocator()->New<GlobalScope>(Allocator());
+    }
+
+    scope_ = topScope_;
+}
+
+ParameterDecl *Binder::AddParamDecl(const ir::AstNode *param)
+{
+    ASSERT(scope_->IsFunctionParamScope() || scope_->IsCatchParamScope());
+    auto [decl, node] = static_cast<ParamScope *>(scope_)->AddParamDecl(Allocator(), param);
+
+    if (!node) {
+        return decl;
+    }
+
+    ThrowRedeclaration(node->Start(), decl->Name());
+}
+
+void Binder::ThrowRedeclaration(const lexer::SourcePosition &pos, const util::StringView &name)
+{
+    lexer::LineIndex index(program_->SourceCode());
+    lexer::SourceLocation loc = index.GetLocation(pos);
+
+    std::stringstream ss;
+    ss << "Variable '" << name << "' has already been declared.";
+    throw Error(ErrorType::SYNTAX, ss.str(), loc.line, loc.col);
+}
+
+void Binder::IdentifierAnalysis()
+{
+    ASSERT(program_->Ast());
+    ASSERT(scope_ == topScope_);
+
+    BuildFunction(topScope_, "main");
+    ResolveReferences(program_->Ast());
+    AddMandatoryParams();
+}
+
+void Binder::LookupReference(const util::StringView &name)
+{
+    ScopeFindResult res = scope_->Find(name);
+    if (res.level == 0) {
+        return;
+    }
+
+    ASSERT(res.variable);
+    res.variable->SetLexical(res.scope);
+}
+
+void Binder::InstantiateArguments()
+{
+    auto *iter = scope_;
+    while (true) {
+        Scope *scope = iter->IsFunctionParamScope() ? iter : iter->EnclosingVariableScope();
+
+        const auto *node = scope->Node();
+
+        if (scope->IsLoopScope()) {
+            iter = scope->Parent();
+            continue;
+        }
+
+        if (!node->IsScriptFunction()) {
+            break;
+        }
+
+        if (!node->AsScriptFunction()->IsArrow()) {
+            auto *argumentsVariable =
+                scope->AddDecl<ConstDecl, LocalVariable>(Allocator(), FUNCTION_ARGUMENTS, VariableFlags::INITIALIZED);
+
+            if (iter->IsFunctionParamScope()) {
+                if (!argumentsVariable) {
+                    break;
+                }
+
+                scope = iter->AsFunctionParamScope()->GetFunctionScope();
+                scope->Bindings().insert({argumentsVariable->Name(), argumentsVariable});
+            }
+
+            scope->AsVariableScope()->AddFlag(VariableScopeFlags::USE_ARGS);
+
+            break;
+        }
+
+        iter = scope->Parent();
+    }
+}
+
+void Binder::LookupIdentReference(ir::Identifier *ident)
+{
+    if (ident->Name().Is(FUNCTION_ARGUMENTS)) {
+        InstantiateArguments();
+    }
+
+    ScopeFindResult res = scope_->Find(ident->Name());
+    if (res.level != 0) {
+        ASSERT(res.variable);
+        res.variable->SetLexical(res.scope);
+    }
+
+    if (!res.variable) {
+        return;
+    }
+
+    if (res.variable->Declaration()->IsLetOrConstDecl() && !res.variable->HasFlag(VariableFlags::INITIALIZED)) {
+        ident->SetTdz();
+    }
+
+    ident->SetVariable(res.variable);
+}
+
+void Binder::BuildFunction(FunctionScope *funcScope, util::StringView name)
+{
+    uint32_t idx = functionScopes_.size();
+    functionScopes_.push_back(funcScope);
+
+    std::stringstream ss;
+    ss << "func_" << name << "_" << std::to_string(idx);
+    util::UString internalName(ss.str(), Allocator());
+
+    funcScope->BindName(name, internalName.View());
+}
+
+void Binder::BuildScriptFunction(Scope *outerScope, const ir::ScriptFunction *scriptFunc)
+{
+    if (scriptFunc->IsArrow()) {
+        VariableScope *outerVarScope = outerScope->EnclosingVariableScope();
+        outerVarScope->AddFlag(VariableScopeFlags::INNER_ARROW);
+    }
+
+    BuildFunction(scope_->AsFunctionScope(), util::Helpers::FunctionName(scriptFunc));
+}
+
+void Binder::BuildVarDeclaratorId(const ir::AstNode *parent, ir::AstNode *childNode)
+{
+    childNode->SetParent(parent);
+
+    switch (childNode->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            const auto &name = childNode->AsIdentifier()->Name();
+            if (util::Helpers::IsGlobalIdentifier(childNode->AsIdentifier()->Name())) {
+                break;
+            }
+
+            auto *variable = scope_->FindLocal(name);
+            variable->AddFlag(VariableFlags::INITIALIZED);
+            break;
+        }
+        case ir::AstNodeType::OBJECT_PATTERN: {
+            for (auto *prop : childNode->AsObjectPattern()->Properties()) {
+                BuildVarDeclaratorId(childNode, prop);
+            }
+            break;
+        }
+        case ir::AstNodeType::ARRAY_PATTERN: {
+            for (auto *element : childNode->AsArrayPattern()->Elements()) {
+                BuildVarDeclaratorId(childNode, element);
+            }
+            break;
+        }
+        case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+            ResolveReference(childNode, childNode->AsAssignmentPattern()->Right());
+            BuildVarDeclaratorId(childNode, childNode->AsAssignmentPattern()->Left());
+            break;
+        }
+        case ir::AstNodeType::PROPERTY: {
+            ResolveReference(childNode, childNode->AsProperty()->Key());
+            BuildVarDeclaratorId(childNode, childNode->AsProperty()->Value());
+            break;
+        }
+        case ir::AstNodeType::REST_ELEMENT: {
+            BuildVarDeclaratorId(childNode, childNode->AsRestElement()->Argument());
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+void Binder::BuildVarDeclarator(ir::VariableDeclarator *varDecl)
+{
+    if (varDecl->Parent()->AsVariableDeclaration()->Kind() == ir::VariableDeclaration::VariableDeclarationKind::VAR) {
+        ResolveReferences(varDecl);
+        return;
+    }
+
+    if (varDecl->Init()) {
+        ResolveReference(varDecl, varDecl->Init());
+    }
+
+    BuildVarDeclaratorId(varDecl, varDecl->Id());
+}
+
+void Binder::BuildClassDefinition(ir::ClassDefinition *classDef)
+{
+    if (classDef->Parent()->IsClassDeclaration()) {
+        ScopeFindResult res = scope_->Find(classDef->Ident()->Name());
+
+        ASSERT(res.variable && res.variable->Declaration()->IsLetDecl());
+        res.variable->AddFlag(VariableFlags::INITIALIZED);
+    }
+
+    auto scopeCtx = LexicalScope<LocalScope>::Enter(this, classDef->Scope());
+
+    if (classDef->Super()) {
+        ResolveReference(classDef, classDef->Super());
+    }
+
+    if (classDef->Ident()) {
+        ScopeFindResult res = scope_->Find(classDef->Ident()->Name());
+
+        ASSERT(res.variable && res.variable->Declaration()->IsConstDecl());
+        res.variable->AddFlag(VariableFlags::INITIALIZED);
+    }
+
+    ResolveReference(classDef, classDef->Ctor());
+
+    for (auto *stmt : classDef->Body()) {
+        ResolveReference(classDef, stmt);
+    }
+}
+
+void Binder::BuildForUpdateLoop(ir::ForUpdateStatement *forUpdateStmt)
+{
+    auto *loopScope = forUpdateStmt->Scope();
+
+    auto declScopeCtx = LexicalScope<LoopDeclarationScope>::Enter(this, loopScope->DeclScope());
+
+    if (forUpdateStmt->Init()) {
+        ResolveReference(forUpdateStmt, forUpdateStmt->Init());
+    }
+
+    if (forUpdateStmt->Update()) {
+        ResolveReference(forUpdateStmt, forUpdateStmt->Update());
+    }
+
+    auto loopCtx = LexicalScope<LoopScope>::Enter(this, loopScope);
+
+    if (forUpdateStmt->Test()) {
+        ResolveReference(forUpdateStmt, forUpdateStmt->Test());
+    }
+
+    ResolveReference(forUpdateStmt, forUpdateStmt->Body());
+
+    loopCtx.GetScope()->ConvertToVariableScope(Allocator());
+}
+
+void Binder::BuildForInOfLoop(const ir::Statement *parent, binder::LoopScope *loopScope, ir::AstNode *left,
+                              ir::Expression *right, ir::Statement *body)
+{
+    auto declScopeCtx = LexicalScope<LoopDeclarationScope>::Enter(this, loopScope->DeclScope());
+
+    ResolveReference(parent, right);
+    ResolveReference(parent, left);
+
+    auto loopCtx = LexicalScope<LoopScope>::Enter(this, loopScope);
+
+    ResolveReference(parent, body);
+    loopCtx.GetScope()->ConvertToVariableScope(Allocator());
+}
+
+void Binder::BuildCatchClause(ir::CatchClause *catchClauseStmt)
+{
+    if (catchClauseStmt->Param()) {
+        auto paramScopeCtx = LexicalScope<CatchParamScope>::Enter(this, catchClauseStmt->Scope()->ParamScope());
+        ResolveReference(catchClauseStmt, catchClauseStmt->Param());
+    }
+
+    auto scopeCtx = LexicalScope<CatchScope>::Enter(this, catchClauseStmt->Scope());
+    ResolveReference(catchClauseStmt, catchClauseStmt->Body());
+}
+
+void Binder::ResolveReference(const ir::AstNode *parent, ir::AstNode *childNode)
+{
+    childNode->SetParent(parent);
+
+    switch (childNode->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            auto *ident = childNode->AsIdentifier();
+
+            if (ident->IsReference()) {
+                LookupIdentReference(ident);
+            }
+
+            ResolveReferences(childNode);
+            break;
+        }
+        case ir::AstNodeType::SUPER_EXPRESSION: {
+            VariableScope *varScope = scope_->EnclosingVariableScope();
+            varScope->AddFlag(VariableScopeFlags::USE_SUPER);
+
+            ResolveReferences(childNode);
+            break;
+        }
+        case ir::AstNodeType::SCRIPT_FUNCTION: {
+            auto *scriptFunc = childNode->AsScriptFunction();
+            auto *funcScope = scriptFunc->Scope();
+
+            auto *outerScope = scope_;
+
+            {
+                auto paramScopeCtx = LexicalScope<FunctionParamScope>::Enter(this, funcScope->ParamScope());
+
+                for (auto *param : scriptFunc->Params()) {
+                    ResolveReference(scriptFunc, param);
+                }
+            }
+
+            auto scopeCtx = LexicalScope<FunctionScope>::Enter(this, funcScope);
+
+            BuildScriptFunction(outerScope, scriptFunc);
+
+            ResolveReference(scriptFunc, scriptFunc->Body());
+            break;
+        }
+        case ir::AstNodeType::VARIABLE_DECLARATOR: {
+            BuildVarDeclarator(childNode->AsVariableDeclarator());
+
+            break;
+        }
+        case ir::AstNodeType::CLASS_DEFINITION: {
+            BuildClassDefinition(childNode->AsClassDefinition());
+
+            break;
+        }
+        case ir::AstNodeType::CLASS_PROPERTY: {
+            const ir::ScriptFunction *ctor = util::Helpers::GetContainingConstructor(childNode->AsClassProperty());
+            auto scopeCtx = LexicalScope<FunctionScope>::Enter(this, ctor->Scope());
+
+            ResolveReferences(childNode);
+            break;
+        }
+        case ir::AstNodeType::BLOCK_STATEMENT: {
+            auto scopeCtx = LexicalScope<Scope>::Enter(this, childNode->AsBlockStatement()->Scope());
+
+            ResolveReferences(childNode);
+            break;
+        }
+        case ir::AstNodeType::SWITCH_STATEMENT: {
+            auto scopeCtx = LexicalScope<LocalScope>::Enter(this, childNode->AsSwitchStatement()->Scope());
+
+            ResolveReferences(childNode);
+            break;
+        }
+        case ir::AstNodeType::DO_WHILE_STATEMENT: {
+            auto *doWhileStatement = childNode->AsDoWhileStatement();
+
+            {
+                auto loopScopeCtx = LexicalScope<LoopScope>::Enter(this, doWhileStatement->Scope());
+                ResolveReference(doWhileStatement, doWhileStatement->Body());
+            }
+
+            ResolveReference(doWhileStatement, doWhileStatement->Test());
+            break;
+        }
+        case ir::AstNodeType::WHILE_STATEMENT: {
+            auto *whileStatement = childNode->AsWhileStatement();
+            ResolveReference(whileStatement, whileStatement->Test());
+
+            auto loopScopeCtx = LexicalScope<LoopScope>::Enter(this, whileStatement->Scope());
+            ResolveReference(whileStatement, whileStatement->Body());
+
+            break;
+        }
+        case ir::AstNodeType::FOR_UPDATE_STATEMENT: {
+            BuildForUpdateLoop(childNode->AsForUpdateStatement());
+            break;
+        }
+        case ir::AstNodeType::FOR_IN_STATEMENT: {
+            auto *forInStmt = childNode->AsForInStatement();
+            BuildForInOfLoop(forInStmt, forInStmt->Scope(), forInStmt->Left(), forInStmt->Right(), forInStmt->Body());
+
+            break;
+        }
+        case ir::AstNodeType::FOR_OF_STATEMENT: {
+            auto *forOfStmt = childNode->AsForOfStatement();
+            BuildForInOfLoop(forOfStmt, forOfStmt->Scope(), forOfStmt->Left(), forOfStmt->Right(), forOfStmt->Body());
+            break;
+        }
+        case ir::AstNodeType::CATCH_CLAUSE: {
+            BuildCatchClause(childNode->AsCatchClause());
+            break;
+        }
+        default: {
+            ResolveReferences(childNode);
+            break;
+        }
+    }
+}
+void Binder::ResolveReferences(const ir::AstNode *parent)
+{
+    parent->Iterate([this, parent](auto *childNode) { ResolveReference(parent, childNode); });
+}
+
+void Binder::AddMandatoryParam(const std::string_view &name)
+{
+    ASSERT(scope_->IsFunctionVariableScope());
+
+    auto *decl = Allocator()->New<ParameterDecl>(name);
+    auto *param = Allocator()->New<LocalVariable>(decl, VariableFlags::VAR);
+
+    auto &funcParams = scope_->AsFunctionVariableScope()->ParamScope()->Params();
+    funcParams.insert(funcParams.begin(), param);
+    scope_->AsFunctionVariableScope()->Bindings().insert({decl->Name(), param});
+}
+
+void Binder::AddMandatoryParams(const MandatoryParams &params)
+{
+    for (auto iter = params.rbegin(); iter != params.rend(); iter++) {
+        AddMandatoryParam(*iter);
+    }
+}
+
+void Binder::AddMandatoryParams()
+{
+    ASSERT(scope_ == topScope_);
+    ASSERT(!functionScopes_.empty());
+    auto iter = functionScopes_.begin();
+    [[maybe_unused]] auto *funcScope = *iter++;
+
+    ASSERT(funcScope->IsGlobalScope() || funcScope->IsModuleScope());
+    AddMandatoryParams(FUNCTION_MANDATORY_PARAMS);
+
+    for (; iter != functionScopes_.end(); iter++) {
+        funcScope = *iter;
+        const auto *scriptFunc = funcScope->Node()->AsScriptFunction();
+
+        auto scopeCtx = LexicalScope<FunctionScope>::Enter(this, funcScope);
+
+        if (!scriptFunc->IsArrow()) {
+            AddMandatoryParams(FUNCTION_MANDATORY_PARAMS);
+            continue;
+        }
+
+        const ir::ScriptFunction *ctor = util::Helpers::GetContainingConstructor(scriptFunc);
+        bool lexicalFunctionObject {};
+
+        if (ctor && util::Helpers::GetClassDefiniton(ctor)->Super() &&
+            funcScope->HasFlag(VariableScopeFlags::USE_SUPER)) {
+            ASSERT(ctor->Scope()->HasFlag(VariableScopeFlags::INNER_ARROW));
+            ctor->Scope()->AddFlag(VariableScopeFlags::SET_LEXICAL_FUNCTION);
+            lexicalFunctionObject = true;
+            AddMandatoryParams(CTOR_ARROW_MANDATORY_PARAMS);
+        } else {
+            AddMandatoryParams(ARROW_MANDATORY_PARAMS);
+        }
+
+        LookupReference(MANDATORY_PARAM_NEW_TARGET);
+        LookupReference(MANDATORY_PARAM_THIS);
+
+        if (funcScope->HasFlag(VariableScopeFlags::USE_ARGS)) {
+            LookupReference(FUNCTION_ARGUMENTS);
+        }
+
+        if (lexicalFunctionObject) {
+            LookupReference(MANDATORY_PARAM_FUNC);
+        }
+    }
+}
+}  // namespace panda::es2panda::binder
diff --git a/es2panda/binder/binder.h b/es2panda/binder/binder.h
new file mode 100644
index 0000000000000000000000000000000000000000..28f4b038d2ecfe000b020cd6552496d5d681d9d0
--- /dev/null
+++ b/es2panda/binder/binder.h
@@ -0,0 +1,210 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_BINDER_BINDER_H
+#define ES2PANDA_BINDER_BINDER_H
+
+#include <binder/scope.h>
+#include <binder/variableFlags.h>
+#include <lexer/token/sourceLocation.h>
+#include <macros.h>
+#include <parser/program/program.h>
+
+namespace panda::es2panda::ir {
+class AstNode;
+class BlockStatement;
+class CatchClause;
+class ClassDefinition;
+class Expression;
+class ForUpdateStatement;
+class Identifier;
+class ScriptFunction;
+class Statement;
+class VariableDeclarator;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::binder {
+class Scope;
+class VariableScope;
+
+class Binder {
+public:
+    explicit Binder(parser::Program *program) : program_(program), functionScopes_(Allocator()->Adapter()) {}
+    NO_COPY_SEMANTIC(Binder);
+    DEFAULT_MOVE_SEMANTIC(Binder);
+    ~Binder() = default;
+
+    void InitTopScope();
+    void IdentifierAnalysis();
+
+    template <typename T, typename... Args>
+    T *AddDecl(const lexer::SourcePosition &pos, Args &&... args);
+
+    template <typename T, typename... Args>
+    T *AddTsDecl(const lexer::SourcePosition &pos, Args &&... args);
+
+    ParameterDecl *AddParamDecl(const ir::AstNode *param);
+
+    Scope *GetScope() const
+    {
+        return scope_;
+    }
+
+    GlobalScope *TopScope() const
+    {
+        return topScope_;
+    }
+
+    [[noreturn]] void ThrowRedeclaration(const lexer::SourcePosition &pos, const util::StringView &name);
+
+    template <typename T>
+    friend class LexicalScope;
+
+    inline ArenaAllocator *Allocator() const
+    {
+        return program_->Allocator();
+    }
+
+    const ArenaVector<FunctionScope *> &Functions() const
+    {
+        return functionScopes_;
+    }
+
+    ArenaVector<FunctionScope *> Functions()
+    {
+        return functionScopes_;
+    }
+
+    const parser::Program *Program() const
+    {
+        return program_;
+    }
+
+    static constexpr std::string_view FUNCTION_ARGUMENTS = "arguments";
+    static constexpr std::string_view MANDATORY_PARAM_FUNC = "=f";
+    static constexpr std::string_view MANDATORY_PARAM_NEW_TARGET = "=nt";
+    static constexpr std::string_view MANDATORY_PARAM_THIS = "=t";
+
+    static constexpr uint32_t MANDATORY_PARAM_FUNC_REG = 0;
+    static constexpr uint32_t MANDATORY_PARAMS_NUMBER = 3;
+
+    static constexpr std::string_view LEXICAL_MANDATORY_PARAM_FUNC = "!f";
+    static constexpr std::string_view LEXICAL_MANDATORY_PARAM_NEW_TARGET = "!nt";
+    static constexpr std::string_view LEXICAL_MANDATORY_PARAM_THIS = "!t";
+
+private:
+    using MandatoryParams = std::array<std::string_view, MANDATORY_PARAMS_NUMBER>;
+
+    static constexpr MandatoryParams FUNCTION_MANDATORY_PARAMS = {MANDATORY_PARAM_FUNC, MANDATORY_PARAM_NEW_TARGET,
+                                                                  MANDATORY_PARAM_THIS};
+
+    static constexpr MandatoryParams ARROW_MANDATORY_PARAMS = {MANDATORY_PARAM_FUNC, LEXICAL_MANDATORY_PARAM_NEW_TARGET,
+                                                               LEXICAL_MANDATORY_PARAM_THIS};
+
+    static constexpr MandatoryParams CTOR_ARROW_MANDATORY_PARAMS = {
+        LEXICAL_MANDATORY_PARAM_FUNC, LEXICAL_MANDATORY_PARAM_NEW_TARGET, LEXICAL_MANDATORY_PARAM_THIS};
+
+    void AddMandatoryParam(const std::string_view &name);
+    void AddMandatoryParams(const MandatoryParams &params);
+    void AddMandatoryParams();
+    void BuildFunction(FunctionScope *funcScope, util::StringView name);
+    void BuildScriptFunction(Scope *outerScope, const ir::ScriptFunction *scriptFunc);
+    void BuildClassDefinition(ir::ClassDefinition *classDef);
+    void LookupReference(const util::StringView &name);
+    void InstantiateArguments();
+    void BuildVarDeclarator(ir::VariableDeclarator *varDecl);
+    void BuildVarDeclaratorId(const ir::AstNode *parent, ir::AstNode *childNode);
+    void BuildForUpdateLoop(ir::ForUpdateStatement *forUpdateStmt);
+    void BuildForInOfLoop(const ir::Statement *parent, binder::LoopScope *loopScope, ir::AstNode *left,
+                          ir::Expression *right, ir::Statement *body);
+    void BuildCatchClause(ir::CatchClause *catchClauseStmt);
+    void LookupIdentReference(ir::Identifier *ident);
+    void ResolveReference(const ir::AstNode *parent, ir::AstNode *childNode);
+    void ResolveReferences(const ir::AstNode *parent);
+
+    parser::Program *program_ {};
+    GlobalScope *topScope_ {};
+    Scope *scope_ {};
+    ArenaVector<FunctionScope *> functionScopes_;
+};
+
+template <typename T>
+class LexicalScope {
+public:
+    template <typename... Args>
+    explicit LexicalScope(Binder *binder, Args &&... args)
+        : LexicalScope(binder->Allocator()->New<T>(binder->Allocator(), binder->scope_, std::forward<Args>(args)...),
+                       binder)
+    {
+    }
+
+    T *GetScope() const
+    {
+        return scope_;
+    }
+
+    ~LexicalScope()
+    {
+        ASSERT(binder_);
+        binder_->scope_ = prevScope_;
+    }
+
+    [[nodiscard]] static LexicalScope<T> Enter(Binder *binder, T *scope)
+    {
+        LexicalScope<T> lexScope(scope, binder);
+        return lexScope;
+    }
+
+    DEFAULT_MOVE_SEMANTIC(LexicalScope);
+
+private:
+    NO_COPY_SEMANTIC(LexicalScope);
+
+    explicit LexicalScope(T *scope, Binder *binder) : binder_(binder), scope_(scope), prevScope_(binder->scope_)
+    {
+        binder_->scope_ = scope_;
+    }
+
+    Binder *binder_ {};
+    T *scope_ {};
+    Scope *prevScope_ {};
+};
+
+template <typename T, typename... Args>
+T *Binder::AddTsDecl(const lexer::SourcePosition &pos, Args &&... args)
+{
+    T *decl = Allocator()->New<T>(std::forward<Args>(args)...);
+
+    if (scope_->AddTsDecl(Allocator(), decl, program_->Extension())) {
+        return decl;
+    }
+
+    ThrowRedeclaration(pos, decl->Name());
+}
+
+template <typename T, typename... Args>
+T *Binder::AddDecl(const lexer::SourcePosition &pos, Args &&... args)
+{
+    T *decl = Allocator()->New<T>(std::forward<Args>(args)...);
+
+    if (scope_->AddDecl(Allocator(), decl, program_->Extension())) {
+        return decl;
+    }
+
+    ThrowRedeclaration(pos, decl->Name());
+}
+}  // namespace panda::es2panda::binder
+
+#endif
diff --git a/es2panda/binder/declaration.cpp b/es2panda/binder/declaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0af567336506887c4beb0d376507d1762615de4b
--- /dev/null
+++ b/es2panda/binder/declaration.cpp
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "declaration.h"
+
+namespace panda::es2panda::binder {
+
+}  // namespace panda::es2panda::binder
diff --git a/es2panda/binder/declaration.h b/es2panda/binder/declaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab65a7579ac6db9768e837f80d82e57f8cbcdd62
--- /dev/null
+++ b/es2panda/binder/declaration.h
@@ -0,0 +1,313 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_SCOPES_DECLARATION_H
+#define ES2PANDA_COMPILER_SCOPES_DECLARATION_H
+
+#include <binder/variableFlags.h>
+#include <macros.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::ir {
+class AstNode;
+class FunctionDeclaration;
+class TSInterfaceDeclaration;
+class ImportDeclaration;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::binder {
+
+class Scope;
+class LocalScope;
+
+#define DECLARE_CLASSES(decl_kind, className) class className;
+DECLARATION_KINDS(DECLARE_CLASSES)
+#undef DECLARE_CLASSES
+
+class Decl {
+public:
+    virtual ~Decl() = default;
+    NO_COPY_SEMANTIC(Decl);
+    NO_MOVE_SEMANTIC(Decl);
+
+    virtual DeclType Type() const = 0;
+
+    const util::StringView &Name() const
+    {
+        return name_;
+    }
+
+    const ir::AstNode *Node() const
+    {
+        return node_;
+    }
+
+#define DECLARE_CHECKS_CASTS(declKind, className)         \
+    bool Is##className() const                            \
+    {                                                     \
+        return Type() == DeclType::declKind;              \
+    }                                                     \
+    className *As##className()                            \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<className *>(this);       \
+    }                                                     \
+    const className *As##className() const                \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<const className *>(this); \
+    }
+    DECLARATION_KINDS(DECLARE_CHECKS_CASTS)
+#undef DECLARE_CHECKS_CASTS
+
+    void BindNode(const ir::AstNode *node)
+    {
+        node_ = node;
+    }
+
+    bool IsLetOrConstDecl() const
+    {
+        return IsLetDecl() || IsConstDecl();
+    }
+
+protected:
+    explicit Decl(util::StringView name) : name_(name) {}
+
+    util::StringView name_;
+    const ir::AstNode *node_ {};
+};
+
+template <typename T>
+class MultiDecl : public Decl {
+public:
+    explicit MultiDecl(ArenaAllocator *allocator, util::StringView name)
+        : Decl(name), declarations_(allocator->Adapter())
+    {
+    }
+
+    const ArenaVector<T *> &Decls() const
+    {
+        return declarations_;
+    }
+
+    void Add(T *decl)
+    {
+        declarations_.push_back(decl);
+    }
+
+private:
+    ArenaVector<T *> declarations_;
+};
+
+class EnumLiteralDecl : public Decl {
+public:
+    explicit EnumLiteralDecl(util::StringView name, bool isConst) : Decl(name), isConst_(isConst) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::ENUM_LITERAL;
+    }
+
+    bool IsConst() const
+    {
+        return isConst_;
+    }
+
+    void BindScope(LocalScope *scope)
+    {
+        scope_ = scope;
+    }
+
+    LocalScope *Scope()
+    {
+        return scope_;
+    }
+
+private:
+    LocalScope *scope_ {};
+    bool isConst_ {};
+};
+
+class InterfaceDecl : public MultiDecl<ir::TSInterfaceDeclaration> {
+public:
+    explicit InterfaceDecl(ArenaAllocator *allocator, util::StringView name) : MultiDecl(allocator, name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::INTERFACE;
+    }
+};
+
+class FunctionDecl : public MultiDecl<ir::FunctionDeclaration> {
+public:
+    explicit FunctionDecl(ArenaAllocator *allocator, util::StringView name, const ir::AstNode *node)
+        : MultiDecl(allocator, name)
+    {
+        node_ = node;
+    }
+
+    DeclType Type() const override
+    {
+        return DeclType::FUNC;
+    }
+};
+
+class TypeParameterDecl : public Decl {
+public:
+    explicit TypeParameterDecl(util::StringView name, const ir::AstNode *node);
+
+    DeclType Type() const override
+    {
+        return DeclType::TYPE_PARAMETER;
+    }
+};
+
+class EnumDecl : public Decl {
+public:
+    explicit EnumDecl(util::StringView name) : Decl(name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::ENUM;
+    }
+};
+
+class TypeAliasDecl : public Decl {
+public:
+    explicit TypeAliasDecl(util::StringView name) : Decl(name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::TYPE_ALIAS;
+    }
+};
+
+class NameSpaceDecl : public Decl {
+public:
+    explicit NameSpaceDecl(util::StringView name) : Decl(name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::NAMESPACE;
+    }
+};
+
+class VarDecl : public Decl {
+public:
+    explicit VarDecl(util::StringView name) : Decl(name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::VAR;
+    }
+};
+
+class LetDecl : public Decl {
+public:
+    explicit LetDecl(util::StringView name) : Decl(name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::LET;
+    }
+};
+
+class ConstDecl : public Decl {
+public:
+    explicit ConstDecl(util::StringView name) : Decl(name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::CONST;
+    }
+};
+
+class ParameterDecl : public Decl {
+public:
+    explicit ParameterDecl(util::StringView name) : Decl(name) {}
+
+    DeclType Type() const override
+    {
+        return DeclType::PARAM;
+    }
+};
+
+class ImportDecl : public Decl {
+public:
+    explicit ImportDecl(util::StringView importName, util::StringView localName)
+        : Decl(localName), importName_(importName)
+    {
+    }
+
+    explicit ImportDecl(util::StringView importName, util::StringView localName, const ir::AstNode *node)
+        : Decl(localName), importName_(importName)
+    {
+        BindNode(node);
+    }
+
+    const util::StringView &ImportName() const
+    {
+        return importName_;
+    }
+
+    const util::StringView &LocalName() const
+    {
+        return name_;
+    }
+
+    DeclType Type() const override
+    {
+        return DeclType::IMPORT;
+    }
+
+private:
+    util::StringView importName_;
+};
+
+class ExportDecl : public Decl {
+public:
+    explicit ExportDecl(util::StringView exportName, util::StringView localName)
+        : Decl(localName), exportName_(exportName)
+    {
+    }
+
+    explicit ExportDecl(util::StringView exportName, util::StringView localName, const ir::AstNode *node)
+        : Decl(localName), exportName_(exportName)
+    {
+        BindNode(node);
+    }
+
+    const util::StringView &ExportName() const
+    {
+        return exportName_;
+    }
+
+    const util::StringView &LocalName() const
+    {
+        return name_;
+    }
+
+    DeclType Type() const override
+    {
+        return DeclType::EXPORT;
+    }
+
+private:
+    util::StringView exportName_;
+};
+
+}  // namespace panda::es2panda::binder
+
+#endif
diff --git a/es2panda/binder/enumMemberResult.h b/es2panda/binder/enumMemberResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0acb7709c25e8dd9bebaf82a7f38d95ef93ea1a
--- /dev/null
+++ b/es2panda/binder/enumMemberResult.h
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_SCOPES_ENUM_MEMBER_RESULT_H
+#define ES2PANDA_COMPILER_SCOPES_ENUM_MEMBER_RESULT_H
+
+#include <util/ustring.h>
+
+#include <variant>
+
+namespace panda::es2panda::binder {
+
+// Note: if the bool operand is present, the expression cannot be evaluated during compliation
+using EnumMemberResult = std::variant<double, util::StringView, bool>;
+
+}  // namespace panda::es2panda::binder
+
+#endif
diff --git a/es2panda/binder/scope.cpp b/es2panda/binder/scope.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..402bdd7a0c77989d8eb0451300936e38afe78d8d
--- /dev/null
+++ b/es2panda/binder/scope.cpp
@@ -0,0 +1,505 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "scope.h"
+
+#include <binder/declaration.h>
+#include <util/helpers.h>
+#include <binder/tsBinding.h>
+#include <binder/variable.h>
+#include <binder/variableFlags.h>
+#include <ir/astNode.h>
+#include <ir/expressions/identifier.h>
+#include <ir/module/exportAllDeclaration.h>
+#include <ir/module/exportNamedDeclaration.h>
+#include <ir/module/exportSpecifier.h>
+#include <ir/module/importDeclaration.h>
+#include <macros.h>
+#include <util/ustring.h>
+
+#include <algorithm>
+#include <sstream>
+
+namespace panda::es2panda::binder {
+
+VariableScope *Scope::EnclosingVariableScope()
+{
+    Scope *iter = this;
+
+    while (iter) {
+        if (iter->IsVariableScope()) {
+            return iter->AsVariableScope();
+        }
+
+        iter = iter->Parent();
+    }
+
+    return nullptr;
+}
+
+Variable *Scope::FindLocal(const util::StringView &name, ResolveBindingOptions options) const
+{
+    if (options & ResolveBindingOptions::INTERFACES) {
+        util::StringView interfaceNameView(binder::TSBinding::ToTSBinding(name));
+
+        auto res = bindings_.find(interfaceNameView);
+        if (res != bindings_.end()) {
+            return res->second;
+        }
+
+        if (!(options & ResolveBindingOptions::BINDINGS)) {
+            return nullptr;
+        }
+    }
+
+    auto res = bindings_.find(name);
+    if (res == bindings_.end()) {
+        return nullptr;
+    }
+
+    return res->second;
+}
+
+ScopeFindResult Scope::Find(const util::StringView &name, ResolveBindingOptions options) const
+{
+    uint32_t level = 0;
+    uint32_t lexLevel = 0;
+    const auto *iter = this;
+
+    while (iter != nullptr) {
+        Variable *v = iter->FindLocal(name, options);
+
+        if (v != nullptr) {
+            return {name, const_cast<Scope *>(iter), level, lexLevel, v};
+        }
+
+        if (iter->IsVariableScope()) {
+            level++;
+
+            if (iter->AsVariableScope()->NeedLexEnv()) {
+                lexLevel++;
+            }
+        }
+
+        iter = iter->Parent();
+    }
+
+    return {name, nullptr, 0, 0, nullptr};
+}
+
+Decl *Scope::FindDecl(const util::StringView &name) const
+{
+    for (auto *it : decls_) {
+        if (it->Name() == name) {
+            return it;
+        }
+    }
+
+    return nullptr;
+}
+
+std::tuple<Scope *, bool> Scope::IterateShadowedVariables(const util::StringView &name, const VariableVisitior &visitor)
+{
+    auto *iter = this;
+
+    while (true) {
+        auto *v = iter->FindLocal(name);
+
+        if (v && visitor(v)) {
+            return {iter, true};
+        }
+
+        if (iter->IsFunctionVariableScope()) {
+            break;
+        }
+
+        iter = iter->Parent();
+    }
+
+    return {iter, false};
+}
+
+bool Scope::AddLocal(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                     [[maybe_unused]] ScriptExtension extension)
+{
+    VariableFlags flags = VariableFlags::NONE;
+    switch (newDecl->Type()) {
+        case DeclType::VAR: {
+            auto [scope, shadowed] = IterateShadowedVariables(
+                newDecl->Name(), [](const Variable *v) { return !v->HasFlag(VariableFlags::VAR); });
+
+            if (shadowed) {
+                return false;
+            }
+
+            VariableFlags varFlags = VariableFlags::HOIST_VAR | VariableFlags::LEXICAL_VAR;
+            if (scope->IsGlobalScope()) {
+                scope->Bindings().insert({newDecl->Name(), allocator->New<GlobalVariable>(newDecl, varFlags)});
+            } else {
+                scope->PropagateBinding<LocalVariable>(allocator, newDecl->Name(), newDecl, varFlags);
+            }
+
+            return true;
+        }
+        case DeclType::ENUM: {
+            bindings_.insert({newDecl->Name(), allocator->New<EnumVariable>(newDecl, false)});
+            return true;
+        }
+        case DeclType::ENUM_LITERAL: {
+            bindings_.insert({newDecl->Name(), allocator->New<LocalVariable>(newDecl, VariableFlags::ENUM_LITERAL)});
+            return true;
+        }
+        case DeclType::INTERFACE: {
+            bindings_.insert({newDecl->Name(), allocator->New<LocalVariable>(newDecl, VariableFlags::INTERFACE)});
+            return true;
+        }
+        case DeclType::FUNC: {
+            flags = VariableFlags::HOIST;
+            [[fallthrough]];
+        }
+        default: {
+            if (currentVariable) {
+                return false;
+            }
+
+            auto [_, shadowed] = IterateShadowedVariables(
+                newDecl->Name(), [](const Variable *v) { return v->HasFlag(VariableFlags::LEXICAL_VAR); });
+            (void)_;
+
+            if (shadowed) {
+                return false;
+            }
+
+            bindings_.insert({newDecl->Name(), allocator->New<LocalVariable>(newDecl, flags)});
+            return true;
+        }
+    }
+}
+
+bool ParamScope::AddParam(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl, VariableFlags flags)
+{
+    ASSERT(newDecl->IsParameterDecl());
+
+    if (currentVariable) {
+        return false;
+    }
+
+    auto *param = allocator->New<LocalVariable>(newDecl, flags);
+
+    params_.push_back(param);
+    bindings_.insert({newDecl->Name(), param});
+    return true;
+}
+
+std::tuple<ParameterDecl *, const ir::AstNode *> ParamScope::AddParamDecl(ArenaAllocator *allocator,
+                                                                          const ir::AstNode *param)
+{
+    const auto [name, pattern] = util::Helpers::ParamName(allocator, param, params_.size());
+
+    auto *decl = NewDecl<ParameterDecl>(allocator, name);
+
+    if (!AddParam(allocator, FindLocal(name), decl, VariableFlags::VAR)) {
+        return {decl, param};
+    }
+
+    if (!pattern) {
+        return {decl, nullptr};
+    }
+
+    std::vector<const ir::Identifier *> bindings = util::Helpers::CollectBindingNames(param);
+
+    for (const auto *binding : bindings) {
+        auto *varDecl = NewDecl<VarDecl>(allocator, binding->Name());
+        varDecl->BindNode(binding);
+
+        if (FindLocal(varDecl->Name())) {
+            return {decl, binding};
+        }
+
+        auto *paramVar = allocator->New<LocalVariable>(varDecl, VariableFlags::VAR);
+        bindings_.insert({varDecl->Name(), paramVar});
+    }
+
+    return {decl, nullptr};
+}
+
+void FunctionParamScope::BindName(ArenaAllocator *allocator, util::StringView name)
+{
+    nameVar_ = AddDecl<ConstDecl, LocalVariable>(allocator, name, VariableFlags::INITIALIZED);
+    functionScope_->Bindings().insert({name, nameVar_});
+}
+
+bool FunctionParamScope::AddBinding([[maybe_unused]] ArenaAllocator *allocator,
+                                    [[maybe_unused]] Variable *currentVariable, [[maybe_unused]] Decl *newDecl,
+                                    [[maybe_unused]] ScriptExtension extension)
+{
+    UNREACHABLE();
+}
+
+bool FunctionScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                               [[maybe_unused]] ScriptExtension extension)
+{
+    switch (newDecl->Type()) {
+        case DeclType::VAR: {
+            return AddVar<LocalVariable>(allocator, currentVariable, newDecl);
+        }
+        case DeclType::FUNC: {
+            return AddFunction<LocalVariable>(allocator, currentVariable, newDecl, extension);
+        }
+        case DeclType::ENUM: {
+            bindings_.insert({newDecl->Name(), allocator->New<EnumVariable>(newDecl, false)});
+            return true;
+        }
+        case DeclType::ENUM_LITERAL: {
+            return AddTSBinding<LocalVariable>(allocator, currentVariable, newDecl, VariableFlags::ENUM_LITERAL);
+        }
+        case DeclType::INTERFACE: {
+            return AddTSBinding<LocalVariable>(allocator, currentVariable, newDecl, VariableFlags::INTERFACE);
+        }
+        default: {
+            return AddLexical<LocalVariable>(allocator, currentVariable, newDecl);
+        }
+    }
+}
+
+bool GlobalScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                             [[maybe_unused]] ScriptExtension extension)
+{
+    switch (newDecl->Type()) {
+        case DeclType::VAR: {
+            return AddVar<GlobalVariable>(allocator, currentVariable, newDecl);
+        }
+        case DeclType::FUNC: {
+            return AddFunction<GlobalVariable>(allocator, currentVariable, newDecl, extension);
+        }
+        case DeclType::ENUM: {
+            bindings_.insert({newDecl->Name(), allocator->New<EnumVariable>(newDecl, false)});
+            return true;
+        }
+        case DeclType::ENUM_LITERAL: {
+            return AddTSBinding<LocalVariable>(allocator, currentVariable, newDecl, VariableFlags::ENUM_LITERAL);
+        }
+        case DeclType::INTERFACE: {
+            return AddTSBinding<LocalVariable>(allocator, currentVariable, newDecl, VariableFlags::INTERFACE);
+        }
+        default: {
+            return AddLexical<LocalVariable>(allocator, currentVariable, newDecl);
+        }
+    }
+
+    return true;
+}
+
+// ModuleScope
+
+bool ModuleScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                             [[maybe_unused]] ScriptExtension extension)
+{
+    switch (newDecl->Type()) {
+        case DeclType::VAR: {
+            return AddVar<LocalVariable>(allocator, currentVariable, newDecl);
+        }
+        case DeclType::FUNC: {
+            return AddFunction<LocalVariable>(allocator, currentVariable, newDecl, extension);
+        }
+        case DeclType::ENUM: {
+            bindings_.insert({newDecl->Name(), allocator->New<EnumVariable>(newDecl, false)});
+            return true;
+        }
+        case DeclType::ENUM_LITERAL: {
+            return AddTSBinding<LocalVariable>(allocator, currentVariable, newDecl, VariableFlags::ENUM_LITERAL);
+        }
+        case DeclType::INTERFACE: {
+            return AddTSBinding<LocalVariable>(allocator, currentVariable, newDecl, VariableFlags::INTERFACE);
+        }
+        case DeclType::IMPORT: {
+            return AddImport(allocator, currentVariable, newDecl);
+        }
+        case DeclType::EXPORT: {
+            return true;
+        }
+        default: {
+            return AddLexical<LocalVariable>(allocator, currentVariable, newDecl);
+        }
+    }
+}
+
+void ModuleScope::AddImportDecl(const ir::ImportDeclaration *importDecl, ImportDeclList &&decls)
+{
+    auto res = imports_.emplace_back(importDecl, decls);
+
+    for (auto &decl : res.second) {
+        decl->BindNode(importDecl);
+    }
+}
+
+void ModuleScope::AddExportDecl(const ir::AstNode *exportDecl, ExportDecl *decl)
+{
+    decl->BindNode(exportDecl);
+
+    ArenaVector<ExportDecl *> decls(allocator_->Adapter());
+    decls.push_back(decl);
+
+    AddExportDecl(exportDecl, std::move(decls));
+}
+
+void ModuleScope::AddExportDecl(const ir::AstNode *exportDecl, ExportDeclList &&decls)
+{
+    auto res = exports_.emplace_back(exportDecl, decls);
+
+    for (auto &decl : res.second) {
+        decl->BindNode(exportDecl);
+    }
+}
+
+bool ModuleScope::AddImport(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl)
+{
+    if (currentVariable && currentVariable->Declaration()->Type() != DeclType::VAR) {
+        return false;
+    }
+
+    if (newDecl->Node()->IsImportNamespaceSpecifier()) {
+        bindings_.insert({newDecl->Name(), allocator->New<LocalVariable>(newDecl, VariableFlags::READONLY)});
+    } else {
+        auto *variable = allocator->New<ModuleVariable>(newDecl, VariableFlags::NONE);
+        variable->ExoticName() = newDecl->AsImportDecl()->ImportName();
+        bindings_.insert({newDecl->Name(), variable});
+    }
+
+    return true;
+}
+
+bool ModuleScope::ExportAnalysis()
+{
+    std::set<util::StringView> exportedNames;
+
+    for (const auto &[exportDecl, decls] : exports_) {
+        if (exportDecl->IsExportAllDeclaration()) {
+            const auto *exportAllDecl = exportDecl->AsExportAllDeclaration();
+
+            if (exportAllDecl->Exported() != nullptr) {
+                auto result = exportedNames.insert(exportAllDecl->Exported()->Name());
+                if (!result.second) {
+                    return false;
+                }
+            }
+
+            continue;
+        }
+
+        if (exportDecl->IsExportNamedDeclaration()) {
+            const auto *exportNamedDecl = exportDecl->AsExportNamedDeclaration();
+
+            if (exportNamedDecl->Source()) {
+                continue;
+            }
+        }
+
+        for (const auto *decl : decls) {
+            binder::Variable *variable = FindLocal(decl->LocalName());
+
+            if (!variable) {
+                continue;
+            }
+
+            auto result = exportedNames.insert(decl->ExportName());
+            if (!result.second) {
+                return false;
+            }
+
+            if (!variable->IsModuleVariable()) {
+                variable->AddFlag(VariableFlags::LOCAL_EXPORT);
+                localExports_.insert({variable, decl->ExportName()});
+            }
+        }
+    }
+
+    return true;
+}
+
+// LocalScope
+
+bool LocalScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                            [[maybe_unused]] ScriptExtension extension)
+{
+    return AddLocal(allocator, currentVariable, newDecl, extension);
+}
+
+void LoopDeclarationScope::ConvertToVariableScope(ArenaAllocator *allocator)
+{
+    if (NeedLexEnv()) {
+        return;
+    }
+
+    for (auto &[name, var] : bindings_) {
+        if (!var->LexicalBound() || !var->Declaration()->IsLetOrConstDecl()) {
+            continue;
+        }
+
+        slotIndex_++;
+        loopType_ = ScopeType::LOOP_DECL;
+        auto *copiedVar = var->AsLocalVariable()->Copy(allocator, var->Declaration());
+        copiedVar->AddFlag(VariableFlags::INITIALIZED | VariableFlags::PER_ITERATION);
+        var->AddFlag(VariableFlags::LOOP_DECL);
+        loopScope_->Bindings().insert({name, copiedVar});
+    }
+
+    if (loopType_ == ScopeType::LOOP_DECL) {
+        slotIndex_ = std::max(slotIndex_, parent_->EnclosingVariableScope()->LexicalSlots());
+        initScope_ = allocator->New<LocalScope>(allocator, parent_);
+        initScope_->BindNode(node_);
+        initScope_->Bindings() = bindings_;
+    }
+}
+
+void LoopScope::ConvertToVariableScope(ArenaAllocator *allocator)
+{
+    declScope_->ConvertToVariableScope(allocator);
+
+    if (loopType_ != ScopeType::LOCAL) {
+        return;
+    }
+
+    for (const auto &[_, var] : bindings_) {
+        (void)_;
+        if (var->LexicalBound() && var->Declaration()->IsLetDecl()) {
+            ASSERT(declScope_->NeedLexEnv());
+            loopType_ = ScopeType::LOOP;
+            break;
+        }
+    }
+
+    if (loopType_ == ScopeType::LOOP) {
+        slotIndex_ = std::max(slotIndex_, declScope_->LexicalSlots());
+    }
+}
+
+bool CatchParamScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                                 [[maybe_unused]] ScriptExtension extension)
+{
+    return AddParam(allocator, currentVariable, newDecl, VariableFlags::INITIALIZED);
+}
+
+bool CatchScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                            [[maybe_unused]] ScriptExtension extension)
+{
+    if (!newDecl->IsVarDecl() && paramScope_->FindLocal(newDecl->Name())) {
+        return false;
+    }
+
+    return AddLocal(allocator, currentVariable, newDecl, extension);
+}
+
+}  // namespace panda::es2panda::binder
diff --git a/es2panda/binder/scope.h b/es2panda/binder/scope.h
new file mode 100644
index 0000000000000000000000000000000000000000..9621858f36bc2b887ed1fcbdbfc61b26cdb6b729
--- /dev/null
+++ b/es2panda/binder/scope.h
@@ -0,0 +1,742 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_SCOPES_SCOPE_H
+#define ES2PANDA_COMPILER_SCOPES_SCOPE_H
+
+#include <binder/declaration.h>
+#include <binder/variable.h>
+#include <parser/program/program.h>
+#include <util/enumbitops.h>
+#include <util/ustring.h>
+
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+namespace panda::es2panda::compiler {
+class IRNode;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::binder {
+
+#define DECLARE_CLASSES(type, className) class className;
+SCOPE_TYPES(DECLARE_CLASSES)
+#undef DECLARE_CLASSES
+
+class Scope;
+class VariableScope;
+class Variable;
+
+using VariableMap = ArenaUnorderedMap<util::StringView, Variable *>;
+
+class ScopeFindResult {
+public:
+    ScopeFindResult() = default;
+    ScopeFindResult(util::StringView n, Scope *s, uint32_t l, Variable *v) : ScopeFindResult(n, s, l, l, v) {}
+    ScopeFindResult(Scope *s, uint32_t l, uint32_t ll, Variable *v) : scope(s), level(l), lexLevel(ll), variable(v) {}
+    ScopeFindResult(util::StringView n, Scope *s, uint32_t l, uint32_t ll, Variable *v)
+        : name(n), scope(s), level(l), lexLevel(ll), variable(v)
+    {
+    }
+
+    util::StringView name {};
+    Scope *scope {};
+    uint32_t level {};
+    uint32_t lexLevel {};
+    Variable *variable {};
+};
+
+class Scope {
+public:
+    virtual ~Scope() = default;
+    NO_COPY_SEMANTIC(Scope);
+    NO_MOVE_SEMANTIC(Scope);
+
+    virtual ScopeType Type() const = 0;
+
+#define DECLARE_CHECKS_CASTS(scopeType, className)        \
+    bool Is##className() const                            \
+    {                                                     \
+        return Type() == ScopeType::scopeType;            \
+    }                                                     \
+    className *As##className()                            \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<className *>(this);       \
+    }                                                     \
+    const className *As##className() const                \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<const className *>(this); \
+    }
+    SCOPE_TYPES(DECLARE_CHECKS_CASTS)
+#undef DECLARE_CHECKS_CASTS
+
+    bool IsVariableScope() const
+    {
+        return Type() > ScopeType::LOCAL;
+    }
+
+    bool IsFunctionVariableScope() const
+    {
+        return Type() >= ScopeType::FUNCTION;
+    }
+
+    FunctionScope *AsFunctionVariableScope()
+    {
+        ASSERT(IsFunctionVariableScope());
+        return reinterpret_cast<FunctionScope *>(this);
+    }
+
+    const FunctionScope *AsFunctionVariableScope() const
+    {
+        ASSERT(IsFunctionVariableScope());
+        return reinterpret_cast<const FunctionScope *>(this);
+    }
+
+    VariableScope *AsVariableScope()
+    {
+        ASSERT(IsVariableScope());
+        return reinterpret_cast<VariableScope *>(this);
+    }
+
+    const VariableScope *AsVariableScope() const
+    {
+        ASSERT(IsVariableScope());
+        return reinterpret_cast<const VariableScope *>(this);
+    }
+
+    VariableScope *EnclosingVariableScope();
+
+    const ArenaVector<Decl *> &Decls() const
+    {
+        return decls_;
+    }
+
+    Scope *Parent()
+    {
+        return parent_;
+    }
+
+    const Scope *Parent() const
+    {
+        return parent_;
+    }
+
+    const compiler::IRNode *ScopeStart() const
+    {
+        return startIns_;
+    }
+
+    const compiler::IRNode *ScopeEnd() const
+    {
+        return endIns_;
+    }
+
+    void SetScopeStart(const compiler::IRNode *ins)
+    {
+        startIns_ = ins;
+    }
+
+    void SetScopeEnd(const compiler::IRNode *ins)
+    {
+        endIns_ = ins;
+    }
+
+    const ir::AstNode *Node() const
+    {
+        return node_;
+    }
+
+    void BindNode(const ir::AstNode *node)
+    {
+        node_ = node;
+    }
+
+    bool AddDecl(ArenaAllocator *allocator, Decl *decl, [[maybe_unused]] ScriptExtension extension)
+    {
+        decls_.push_back(decl);
+        return AddBinding(allocator, FindLocal(decl->Name()), decl, extension);
+    }
+
+    bool AddTsDecl(ArenaAllocator *allocator, Decl *decl, [[maybe_unused]] ScriptExtension extension)
+    {
+        decls_.push_back(decl);
+        return AddBinding(allocator, FindLocal(decl->Name(), ResolveBindingOptions::ALL), decl, extension);
+    }
+
+    template <typename T, typename... Args>
+    T *NewDecl(ArenaAllocator *allocator, Args &&... args);
+
+    template <typename DeclType, typename VariableType>
+    VariableType *AddDecl(ArenaAllocator *allocator, util::StringView name, VariableFlags flags);
+
+    template <typename DeclType = binder::LetDecl, typename VariableType = binder::LocalVariable>
+    static VariableType *CreateVar(ArenaAllocator *allocator, util::StringView name, VariableFlags flags,
+                                   const ir::AstNode *node);
+
+    template <typename T, typename... Args>
+    void PropagateBinding(ArenaAllocator *allocator, util::StringView name, Args &&... args);
+
+    VariableMap &Bindings()
+    {
+        return bindings_;
+    }
+
+    const VariableMap &Bindings() const
+    {
+        return bindings_;
+    }
+
+    virtual bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                            [[maybe_unused]] ScriptExtension extension) = 0;
+
+    Variable *FindLocal(const util::StringView &name,
+                        ResolveBindingOptions options = ResolveBindingOptions::BINDINGS) const;
+
+    ScopeFindResult Find(const util::StringView &name,
+                         ResolveBindingOptions options = ResolveBindingOptions::BINDINGS) const;
+
+    Decl *FindDecl(const util::StringView &name) const;
+
+protected:
+    explicit Scope(ArenaAllocator *allocator, Scope *parent)
+        : parent_(parent), decls_(allocator->Adapter()), bindings_(allocator->Adapter())
+    {
+    }
+
+    /**
+     * @return true - if the variable is shadowed
+     *         false - otherwise
+     */
+    using VariableVisitior = std::function<bool(const Variable *)>;
+
+    /**
+     * @return true - if the variable is shadowed
+     *         false - otherwise
+     */
+    std::tuple<Scope *, bool> IterateShadowedVariables(const util::StringView &name, const VariableVisitior &visitor);
+
+    bool AddLocal(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                  [[maybe_unused]] ScriptExtension extension);
+
+    Scope *parent_ {};
+    ArenaVector<Decl *> decls_;
+    VariableMap bindings_;
+    const ir::AstNode *node_ {};
+    const compiler::IRNode *startIns_ {};
+    const compiler::IRNode *endIns_ {};
+};
+
+class VariableScope : public Scope {
+public:
+    ~VariableScope() override = default;
+    NO_COPY_SEMANTIC(VariableScope);
+    NO_MOVE_SEMANTIC(VariableScope);
+
+    void AddFlag(VariableScopeFlags flag)
+    {
+        flags_ |= flag;
+    }
+
+    void ClearFlag(VariableScopeFlags flag)
+    {
+        flags_ &= ~flag;
+    }
+
+    bool HasFlag(VariableScopeFlags flag) const
+    {
+        return (flags_ & flag) != 0;
+    }
+
+    uint32_t NextSlot()
+    {
+        return slotIndex_++;
+    }
+
+    uint32_t LexicalSlots() const
+    {
+        return slotIndex_;
+    }
+
+    bool NeedLexEnv() const
+    {
+        return slotIndex_ != 0;
+    }
+
+protected:
+    explicit VariableScope(ArenaAllocator *allocator, Scope *parent) : Scope(allocator, parent) {}
+
+    template <typename T>
+    bool AddVar(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl);
+
+    template <typename T>
+    bool AddFunction(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                     [[maybe_unused]] ScriptExtension extension);
+
+    template <typename T>
+    bool AddTSBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl, VariableFlags flags);
+
+    template <typename T>
+    bool AddLexical(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl);
+
+    VariableScopeFlags flags_ {};
+    uint32_t slotIndex_ {};
+};
+
+class ParamScope : public Scope {
+public:
+    ScopeType Type() const override
+    {
+        return ScopeType::PARAM;
+    }
+
+    ArenaVector<LocalVariable *> &Params()
+    {
+        return params_;
+    }
+
+    const ArenaVector<LocalVariable *> &Params() const
+    {
+        return params_;
+    }
+
+    std::tuple<ParameterDecl *, const ir::AstNode *> AddParamDecl(ArenaAllocator *allocator, const ir::AstNode *param);
+
+protected:
+    explicit ParamScope(ArenaAllocator *allocator, Scope *parent)
+        : Scope(allocator, parent), params_(allocator->Adapter())
+    {
+    }
+
+    bool AddParam(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl, VariableFlags flags);
+
+    ArenaVector<LocalVariable *> params_;
+};
+
+class FunctionScope;
+
+class FunctionParamScope : public ParamScope {
+public:
+    explicit FunctionParamScope(ArenaAllocator *allocator, Scope *parent) : ParamScope(allocator, parent) {}
+
+    FunctionScope *GetFunctionScope() const
+    {
+        return functionScope_;
+    }
+
+    void BindFunctionScope(FunctionScope *funcScope)
+    {
+        functionScope_ = funcScope;
+    }
+
+    LocalVariable *NameVar() const
+    {
+        return nameVar_;
+    }
+
+    void BindName(ArenaAllocator *allocator, util::StringView name);
+
+    ScopeType Type() const override
+    {
+        return ScopeType::FUNCTION_PARAM;
+    }
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override;
+
+    friend class FunctionScope;
+    template <typename E, typename T>
+    friend class ScopeWithParamScope;
+
+private:
+    FunctionScope *functionScope_ {};
+    LocalVariable *nameVar_ {};
+};
+
+template <typename E, typename T>
+class ScopeWithParamScope : public E {
+public:
+    explicit ScopeWithParamScope(ArenaAllocator *allocator, Scope *parent) : E(allocator, parent) {}
+
+    void BindParamScope(T *paramScope)
+    {
+        AssignParamScope(paramScope);
+        this->bindings_ = paramScope->Bindings();
+    }
+
+    void AssignParamScope(T *paramScope)
+    {
+        ASSERT(this->parent_ == paramScope);
+        ASSERT(this->bindings_.empty());
+
+        paramScope_ = paramScope;
+    }
+
+    T *ParamScope()
+    {
+        return paramScope_;
+    }
+
+    const T *ParamScope() const
+    {
+        return paramScope_;
+    }
+
+protected:
+    T *paramScope_;
+};
+
+class FunctionScope : public ScopeWithParamScope<VariableScope, FunctionParamScope> {
+public:
+    explicit FunctionScope(ArenaAllocator *allocator, Scope *parent) : ScopeWithParamScope(allocator, parent) {}
+
+    ScopeType Type() const override
+    {
+        return ScopeType::FUNCTION;
+    }
+
+    void BindName(util::StringView name, util::StringView internalName)
+    {
+        name_ = name;
+        internalName_ = internalName;
+    }
+
+    const util::StringView &Name() const
+    {
+        return name_;
+    }
+
+    const util::StringView &InternalName() const
+    {
+        return internalName_;
+    }
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override;
+
+private:
+    util::StringView name_ {};
+    util::StringView internalName_ {};
+};
+
+class LocalScope : public Scope {
+public:
+    explicit LocalScope(ArenaAllocator *allocator, Scope *parent) : Scope(allocator, parent) {}
+
+    ScopeType Type() const override
+    {
+        return ScopeType::LOCAL;
+    }
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override;
+};
+
+class CatchParamScope : public ParamScope {
+public:
+    explicit CatchParamScope(ArenaAllocator *allocator, Scope *parent) : ParamScope(allocator, parent) {}
+
+    ScopeType Type() const override
+    {
+        return ScopeType::CATCH_PARAM;
+    }
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override;
+
+    friend class CatchScope;
+};
+
+class CatchScope : public ScopeWithParamScope<LocalScope, CatchParamScope> {
+public:
+    explicit CatchScope(ArenaAllocator *allocator, Scope *parent) : ScopeWithParamScope(allocator, parent) {}
+
+    ScopeType Type() const override
+    {
+        return ScopeType::CATCH;
+    }
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override;
+};
+
+class LoopScope;
+
+class LoopDeclarationScope : public VariableScope {
+public:
+    explicit LoopDeclarationScope(ArenaAllocator *allocator, Scope *parent) : VariableScope(allocator, parent) {}
+
+    ScopeType Type() const override
+    {
+        return loopType_;
+    }
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override
+    {
+        return AddLocal(allocator, currentVariable, newDecl, extension);
+    }
+
+    Scope *InitScope()
+    {
+        if (NeedLexEnv()) {
+            return initScope_;
+        }
+
+        return this;
+    }
+
+    void ConvertToVariableScope(ArenaAllocator *allocator);
+
+private:
+    friend class LoopScope;
+    LoopScope *loopScope_ {};
+    LocalScope *initScope_ {};
+    ScopeType loopType_ {ScopeType::LOCAL};
+};
+
+class LoopScope : public VariableScope {
+public:
+    explicit LoopScope(ArenaAllocator *allocator, Scope *parent) : VariableScope(allocator, parent) {}
+
+    LoopDeclarationScope *DeclScope()
+    {
+        return declScope_;
+    }
+
+    void BindDecls(LoopDeclarationScope *declScope)
+    {
+        declScope_ = declScope;
+        declScope_->loopScope_ = this;
+    }
+
+    ScopeType Type() const override
+    {
+        return loopType_;
+    }
+
+    void ConvertToVariableScope(ArenaAllocator *allocator);
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override
+    {
+        return AddLocal(allocator, currentVariable, newDecl, extension);
+    }
+
+protected:
+    LoopDeclarationScope *declScope_ {};
+    ScopeType loopType_ {ScopeType::LOCAL};
+};
+
+class GlobalScope : public FunctionScope {
+public:
+    explicit GlobalScope(ArenaAllocator *allocator) : FunctionScope(allocator, nullptr)
+    {
+        auto *paramScope = allocator->New<FunctionParamScope>(allocator, this);
+        paramScope_ = paramScope;
+    }
+
+    ScopeType Type() const override
+    {
+        return ScopeType::GLOBAL;
+    }
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override;
+};
+
+class ModuleScope : public GlobalScope {
+public:
+    template <typename K, typename V>
+    using ModuleEntry = ArenaVector<std::pair<K, V>>;
+    using ImportDeclList = ArenaVector<ImportDecl *>;
+    using ExportDeclList = ArenaVector<ExportDecl *>;
+    using LocalExportNameMap = ArenaMultiMap<binder::Variable *, util::StringView>;
+
+    explicit ModuleScope(ArenaAllocator *allocator)
+        : GlobalScope(allocator),
+          allocator_(allocator),
+          imports_(allocator_->Adapter()),
+          exports_(allocator_->Adapter()),
+          localExports_(allocator_->Adapter())
+    {
+    }
+
+    ScopeType Type() const override
+    {
+        return ScopeType::MODULE;
+    }
+
+    const ModuleEntry<const ir::ImportDeclaration *, ImportDeclList> &Imports() const
+    {
+        return imports_;
+    }
+
+    const ModuleEntry<const ir::AstNode *, ExportDeclList> &Exports() const
+    {
+        return exports_;
+    }
+
+    const LocalExportNameMap &LocalExports() const
+    {
+        return localExports_;
+    }
+
+    void AddImportDecl(const ir::ImportDeclaration *importDecl, ImportDeclList &&decls);
+
+    void AddExportDecl(const ir::AstNode *exportDecl, ExportDecl *decl);
+
+    void AddExportDecl(const ir::AstNode *exportDecl, ExportDeclList &&decls);
+
+    bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                    [[maybe_unused]] ScriptExtension extension) override;
+
+    bool ExportAnalysis();
+
+private:
+    bool AddImport(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl);
+
+    ArenaAllocator *allocator_;
+    ModuleEntry<const ir::ImportDeclaration *, ImportDeclList> imports_;
+    ModuleEntry<const ir::AstNode *, ExportDeclList> exports_;
+    LocalExportNameMap localExports_;
+};
+
+template <typename T>
+bool VariableScope::AddVar(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl)
+{
+    if (!currentVariable) {
+        bindings_.insert({newDecl->Name(), allocator->New<T>(newDecl, VariableFlags::HOIST_VAR)});
+        return true;
+    }
+
+    switch (currentVariable->Declaration()->Type()) {
+        case DeclType::VAR: {
+            currentVariable->Reset(newDecl, VariableFlags::HOIST_VAR);
+            break;
+        }
+        case DeclType::PARAM:
+        case DeclType::FUNC: {
+            break;
+        }
+        default: {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+template <typename T>
+bool VariableScope::AddFunction(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                                [[maybe_unused]] ScriptExtension extension)
+{
+    VariableFlags flags = (extension == ScriptExtension::JS) ? VariableFlags::HOIST_VAR : VariableFlags::HOIST;
+
+    if (!currentVariable) {
+        bindings_.insert({newDecl->Name(), allocator->New<T>(newDecl, flags)});
+        return true;
+    }
+
+    if (extension != ScriptExtension::JS || IsModuleScope()) {
+        return false;
+    }
+
+    switch (currentVariable->Declaration()->Type()) {
+        case DeclType::VAR:
+        case DeclType::FUNC: {
+            currentVariable->Reset(newDecl, VariableFlags::HOIST_VAR);
+            break;
+        }
+        default: {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+template <typename T>
+bool VariableScope::AddTSBinding(ArenaAllocator *allocator, [[maybe_unused]] Variable *currentVariable, Decl *newDecl,
+                                 VariableFlags flags)
+{
+    ASSERT(!currentVariable);
+    bindings_.insert({newDecl->Name(), allocator->New<T>(newDecl, flags)});
+    return true;
+}
+
+template <typename T>
+bool VariableScope::AddLexical(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl)
+{
+    if (currentVariable) {
+        return false;
+    }
+
+    bindings_.insert({newDecl->Name(), allocator->New<T>(newDecl, VariableFlags::NONE)});
+    return true;
+}
+
+template <typename T, typename... Args>
+T *Scope::NewDecl(ArenaAllocator *allocator, Args &&... args)
+{
+    T *decl = allocator->New<T>(std::forward<Args>(args)...);
+    decls_.push_back(decl);
+
+    return decl;
+}
+
+template <typename DeclType, typename VariableType>
+VariableType *Scope::AddDecl(ArenaAllocator *allocator, util::StringView name, VariableFlags flags)
+{
+    if (FindLocal(name)) {
+        return nullptr;
+    }
+
+    auto *decl = allocator->New<DeclType>(name);
+    auto *variable = allocator->New<VariableType>(decl, flags);
+
+    decls_.push_back(decl);
+    bindings_.insert({decl->Name(), variable});
+
+    return variable;
+}
+
+template <typename DeclType, typename VariableType>
+VariableType *Scope::CreateVar(ArenaAllocator *allocator, util::StringView name, VariableFlags flags,
+                               const ir::AstNode *node)
+{
+    auto *decl = allocator->New<DeclType>(name);
+    auto *variable = allocator->New<VariableType>(decl, flags);
+    decl->BindNode(node);
+    return variable;
+}
+
+template <typename T, typename... Args>
+void Scope::PropagateBinding(ArenaAllocator *allocator, util::StringView name, Args &&... args)
+{
+    auto res = bindings_.find(name);
+    if (res == bindings_.end()) {
+        bindings_.insert({name, allocator->New<T>(std::forward<Args>(args)...)});
+        return;
+    }
+
+    res->second->Reset(std::forward<Args>(args)...);
+}
+
+}  // namespace panda::es2panda::binder
+
+#endif
diff --git a/es2panda/binder/tsBinding.h b/es2panda/binder/tsBinding.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d586ceaf481ce0ef30f02d82e494f8f3732e50d
--- /dev/null
+++ b/es2panda/binder/tsBinding.h
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_BINDER_TS_BINDING_H
+#define ES2PANDA_BINDER_TS_BINDING_H
+
+#include <util/ustring.h>
+
+#include <variant>
+
+namespace panda::es2panda::binder {
+// Note: if the bool operand is present, the expression cannot be evaluated during compliation
+using EnumMemberResult = std::variant<double, util::StringView, bool>;
+
+class TSBinding : public util::UString {
+public:
+    explicit TSBinding(ArenaAllocator *allocator, util::StringView name)
+        : util::UString(std::string {TS_PREFIX}, allocator)
+    {
+        Append(name);
+    }
+
+    static std::string ToTSBinding(util::StringView name)
+    {
+        return std::string {TS_PREFIX}.append(name.Utf8());
+    }
+
+    static constexpr std::string_view TS_PREFIX = "#";
+};
+}  // namespace panda::es2panda::binder
+
+#endif
diff --git a/es2panda/binder/variable.cpp b/es2panda/binder/variable.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb57097d38c93a584423ed6ca4f3937b10ea614a
--- /dev/null
+++ b/es2panda/binder/variable.cpp
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "variable.h"
+
+#include <binder/scope.h>
+
+#include <utility>
+
+namespace panda::es2panda::binder {
+
+LocalVariable::LocalVariable(Decl *decl, VariableFlags flags) : Variable(decl, flags)
+{
+    if (decl->IsConstDecl()) {
+        flags_ |= VariableFlags::READONLY;
+    }
+}
+
+const util::StringView &Variable::Name() const
+{
+    return decl_->Name();
+}
+
+LocalVariable *LocalVariable::Copy(ArenaAllocator *allocator, Decl *decl) const
+{
+    auto *var = allocator->New<LocalVariable>(decl, flags_);
+    var->vreg_ = vreg_;
+    return var;
+}
+
+void LocalVariable::SetLexical(Scope *scope)
+{
+    if (LexicalBound()) {
+        return;
+    }
+
+    VariableScope *varScope = scope->EnclosingVariableScope();
+
+    BindLexEnvSlot(varScope->NextSlot());
+}
+
+void GlobalVariable::SetLexical([[maybe_unused]] Scope *scope) {}
+void ModuleVariable::SetLexical([[maybe_unused]] Scope *scope) {}
+void EnumVariable::SetLexical([[maybe_unused]] Scope *scope) {}
+
+void EnumVariable::ResetDecl(Decl *decl)
+{
+    decl_ = decl;
+}
+
+}  // namespace panda::es2panda::binder
diff --git a/es2panda/binder/variable.h b/es2panda/binder/variable.h
new file mode 100644
index 0000000000000000000000000000000000000000..4302048a8bf2ccafe9887e3574da5bfd7be16f1c
--- /dev/null
+++ b/es2panda/binder/variable.h
@@ -0,0 +1,254 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_SCOPES_VARIABLE_H
+#define ES2PANDA_COMPILER_SCOPES_VARIABLE_H
+
+#include <binder/enumMemberResult.h>
+#include <binder/variableFlags.h>
+#include <ir/irnode.h>
+#include <macros.h>
+#include <util/ustring.h>
+
+#include <limits>
+
+namespace panda::es2panda::checker {
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+
+class Decl;
+class Scope;
+class VariableScope;
+
+#define DECLARE_CLASSES(type, className) class className;
+VARIABLE_TYPES(DECLARE_CLASSES)
+#undef DECLARE_CLASSES
+
+class Variable {
+public:
+    virtual ~Variable() = default;
+    NO_COPY_SEMANTIC(Variable);
+    NO_MOVE_SEMANTIC(Variable);
+
+    VariableType virtual Type() const = 0;
+
+#define DECLARE_CHECKS_CASTS(variableType, className)     \
+    bool Is##className() const                            \
+    {                                                     \
+        return Type() == VariableType::variableType;      \
+    }                                                     \
+    className *As##className()                            \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<className *>(this);       \
+    }                                                     \
+    const className *As##className() const                \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<const className *>(this); \
+    }
+    VARIABLE_TYPES(DECLARE_CHECKS_CASTS)
+#undef DECLARE_CHECKS_CASTS
+
+    Decl *Declaration() const
+    {
+        return decl_;
+    }
+
+    VariableFlags Flags() const
+    {
+        return flags_;
+    }
+
+    checker::Type *TsType() const
+    {
+        return tsType_;
+    }
+
+    void SetTsType(checker::Type *tsType)
+    {
+        tsType_ = tsType;
+    }
+
+    void AddFlag(VariableFlags flag)
+    {
+        flags_ |= flag;
+    }
+
+    bool HasFlag(VariableFlags flag) const
+    {
+        return (flags_ & flag) != 0;
+    }
+
+    void RemoveFlag(VariableFlags flag)
+    {
+        flags_ &= ~flag;
+    }
+
+    void Reset(Decl *decl, VariableFlags flags)
+    {
+        decl_ = decl;
+        flags_ = flags;
+    }
+
+    bool LexicalBound() const
+    {
+        return HasFlag(VariableFlags::LEXICAL_BOUND);
+    }
+
+    const util::StringView &Name() const;
+    virtual void SetLexical(Scope *scope) = 0;
+
+protected:
+    explicit Variable(Decl *decl, VariableFlags flags) : decl_(decl), flags_(flags) {}
+
+    Decl *decl_;
+    VariableFlags flags_ {};
+    checker::Type *tsType_ {};
+};
+
+class LocalVariable : public Variable {
+public:
+    explicit LocalVariable(Decl *decl, VariableFlags flags);
+
+    VariableType Type() const override
+    {
+        return VariableType::LOCAL;
+    }
+
+    void BindVReg(compiler::VReg vreg)
+    {
+        ASSERT(!LexicalBound());
+        vreg_ = vreg;
+    }
+
+    void BindLexEnvSlot(uint32_t slot)
+    {
+        ASSERT(!LexicalBound());
+        AddFlag(VariableFlags::LEXICAL_BOUND);
+        vreg_ = slot;
+    }
+
+    compiler::VReg Vreg() const
+    {
+        return vreg_;
+    }
+
+    uint32_t LexIdx() const
+    {
+        ASSERT(LexicalBound());
+        return vreg_;
+    }
+
+    void SetLexical([[maybe_unused]] Scope *scope) override;
+    LocalVariable *Copy(ArenaAllocator *allocator, Decl *decl) const;
+
+private:
+    uint32_t vreg_ {};
+};
+
+class GlobalVariable : public Variable {
+public:
+    explicit GlobalVariable(Decl *decl, VariableFlags flags) : Variable(decl, flags) {}
+
+    VariableType Type() const override
+    {
+        return VariableType::GLOBAL;
+    }
+
+    void SetLexical([[maybe_unused]] Scope *scope) override;
+};
+
+class ModuleVariable : public Variable {
+public:
+    explicit ModuleVariable(Decl *decl, VariableFlags flags) : Variable(decl, flags) {}
+
+    VariableType Type() const override
+    {
+        return VariableType::MODULE;
+    }
+
+    compiler::VReg &ModuleReg()
+    {
+        return moduleReg_;
+    }
+
+    compiler::VReg ModuleReg() const
+    {
+        return moduleReg_;
+    }
+
+    const util::StringView &ExoticName() const
+    {
+        return exoticName_;
+    }
+
+    util::StringView &ExoticName()
+    {
+        return exoticName_;
+    }
+
+    void SetLexical([[maybe_unused]] Scope *scope) override;
+
+private:
+    compiler::VReg moduleReg_ {};
+    util::StringView exoticName_ {};
+};
+
+class EnumVariable : public Variable {
+public:
+    explicit EnumVariable(Decl *decl, bool backReference = false)
+        : Variable(decl, VariableFlags::NONE), backReference_(backReference)
+    {
+    }
+
+    VariableType Type() const override
+    {
+        return VariableType::ENUM;
+    }
+
+    void SetValue(EnumMemberResult value)
+    {
+        value_ = value;
+    }
+
+    const EnumMemberResult &Value() const
+    {
+        return value_;
+    }
+
+    bool BackReference() const
+    {
+        return backReference_;
+    }
+
+    void SetBackReference()
+    {
+        backReference_ = true;
+    }
+
+    void ResetDecl(Decl *decl);
+
+    void SetLexical([[maybe_unused]] Scope *scope) override;
+
+private:
+    EnumMemberResult value_ {false};
+    bool backReference_ {};
+};
+
+}  // namespace panda::es2panda::binder
+#endif
diff --git a/es2panda/binder/variableFlags.h b/es2panda/binder/variableFlags.h
new file mode 100644
index 0000000000000000000000000000000000000000..dee8b1475741544e27355e61683873cafe375fb3
--- /dev/null
+++ b/es2panda/binder/variableFlags.h
@@ -0,0 +1,143 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_SCOPES_VARIABLE_FLAGS_H
+#define ES2PANDA_COMPILER_SCOPES_VARIABLE_FLAGS_H
+
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::binder {
+
+#define DECLARATION_KINDS(_)             \
+    _(VAR, VarDecl)                      \
+    _(LET, LetDecl)                      \
+    _(CONST, ConstDecl)                  \
+    _(FUNC, FunctionDecl)                \
+    _(PARAM, ParameterDecl)              \
+    _(IMPORT, ImportDecl)                \
+    _(EXPORT, ExportDecl)                \
+    /* TS */                             \
+    _(TYPE_ALIAS, TypeAliasDecl)         \
+    _(NAMESPACE, NameSpaceDecl)          \
+    _(INTERFACE, InterfaceDecl)          \
+    _(ENUM_LITERAL, EnumLiteralDecl)     \
+    _(TYPE_PARAMETER, TypeParameterDecl) \
+    _(ENUM, EnumDecl)
+
+enum class DeclType {
+    NONE,
+#define DECLARE_TYPES(decl_kind, class_name) decl_kind,
+    DECLARATION_KINDS(DECLARE_TYPES)
+#undef DECLARE_TYPES
+};
+
+#define SCOPE_TYPES(_)                    \
+    _(PARAM, ParamScope)                  \
+    _(CATCH_PARAM, CatchParamScope)       \
+    _(FUNCTION_PARAM, FunctionParamScope) \
+    _(CATCH, CatchScope)                  \
+    _(LOCAL, LocalScope)                  \
+    /* Variable Scopes */                 \
+    _(LOOP, LoopScope)                    \
+    _(LOOP_DECL, LoopDeclarationScope)    \
+    _(FUNCTION, FunctionScope)            \
+    _(GLOBAL, GlobalScope)                \
+    _(MODULE, ModuleScope)
+
+enum class ScopeType {
+#define GEN_SCOPE_TYPES(type, class_name) type,
+    SCOPE_TYPES(GEN_SCOPE_TYPES)
+#undef GEN_SCOPE_TYPES
+};
+
+enum class ResolveBindingOptions {
+    BINDINGS = 1U << 0U,
+    INTERFACES = 1U << 1U,
+
+    ALL = BINDINGS | INTERFACES,
+};
+
+DEFINE_BITOPS(ResolveBindingOptions)
+
+#define VARIABLE_TYPES(_)     \
+    _(LOCAL, LocalVariable)   \
+    _(GLOBAL, GlobalVariable) \
+    _(MODULE, ModuleVariable) \
+    _(ENUM, EnumVariable)
+
+enum class VariableType {
+#define GEN_VARIABLE_TYPES(type, class_name) type,
+    VARIABLE_TYPES(GEN_VARIABLE_TYPES)
+#undef GEN_VARIABLE_TYPES
+};
+
+enum class VariableKind {
+    NONE,
+    VAR,
+    LEXICAL,
+    FUNCTION,
+    MODULE,
+};
+
+enum class VariableFlags {
+    NONE = 0,
+    OPTIONAL = 1 << 0,
+    PROPERTY = 1 << 1,
+    METHOD = 1 << 2,
+    TYPE_ALIAS = 1 << 3,
+    INTERFACE = 1 << 4,
+    ENUM_LITERAL = 1 << 5,
+    READONLY = 1 << 6,
+    COMPUTED = 1 << 7,
+    COMPUTED_IDENT = 1 << 8,
+    COMPUTED_INDEX = 1 << 9,
+    INDEX_NAME = 1 << 10,
+    LOCAL_EXPORT = 1 << 12,
+    INFERED_IN_PATTERN = 1 << 13,
+    REST_ARG = 1 << 14,
+
+    INDEX_LIKE = COMPUTED_INDEX | INDEX_NAME,
+
+    LOOP_DECL = 1 << 25,
+    PER_ITERATION = 1 << 26,
+    LEXICAL_VAR = 1 << 27,
+    HOIST = 1 << 28,
+    VAR = 1 << 29,
+    INITIALIZED = 1 << 30,
+    LEXICAL_BOUND = 1 << 31,
+
+    HOIST_VAR = HOIST | VAR,
+};
+
+DEFINE_BITOPS(VariableFlags)
+
+enum class LetOrConstStatus {
+    INITIALIZED,
+    UNINITIALIZED,
+};
+
+enum class VariableScopeFlags {
+    NONE = 0,
+    SET_LEXICAL_FUNCTION = 1U << 0U,
+    USE_ARGS = 1U << 2U,
+    USE_SUPER = 1U << 3U,
+    INNER_ARROW = 1U << 4U,
+};
+
+DEFINE_BITOPS(VariableScopeFlags)
+
+}  // namespace panda::es2panda::binder
+
+#endif
diff --git a/es2panda/compiler/base/catchTable.cpp b/es2panda/compiler/base/catchTable.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2bafa48df03d8dba1bf3f0b8c0751e40a208a176
--- /dev/null
+++ b/es2panda/compiler/base/catchTable.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "catchTable.h"
+
+#include <compiler/core/pandagen.h>
+
+namespace panda::es2panda::compiler {
+
+TryLabelSet::TryLabelSet(PandaGen *pg)
+    : try_(pg->AllocLabel(), pg->AllocLabel()), catch_(pg->AllocLabel(), pg->AllocLabel())
+{
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/catchTable.h b/es2panda/compiler/base/catchTable.h
new file mode 100644
index 0000000000000000000000000000000000000000..9954ae9ff79d2901a4fb61cd0ce0848c5e67dca7
--- /dev/null
+++ b/es2panda/compiler/base/catchTable.h
@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_BASE_CATCH_TABLE_H
+#define ES2PANDA_COMPILER_BASE_CATCH_TABLE_H
+
+#include <ir/irnode.h>
+#include <compiler/core/labelPair.h>
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class TryLabelSet {
+public:
+    explicit TryLabelSet(PandaGen *pg);
+
+    ~TryLabelSet() = default;
+    DEFAULT_COPY_SEMANTIC(TryLabelSet);
+    DEFAULT_MOVE_SEMANTIC(TryLabelSet);
+
+    const LabelPair &TryLabelPair() const
+    {
+        return try_;
+    }
+
+    const LabelPair &CatchLabelPair() const
+    {
+        return catch_;
+    }
+
+    Label *TryBegin() const
+    {
+        return try_.Begin();
+    }
+
+    Label *TryEnd() const
+    {
+        return try_.End();
+    }
+
+    Label *CatchBegin() const
+    {
+        return catch_.Begin();
+    }
+
+    Label *CatchEnd() const
+    {
+        return catch_.End();
+    }
+
+private:
+    LabelPair try_;
+    LabelPair catch_;
+};
+
+class CatchTable {
+public:
+    CatchTable(PandaGen *pg, uint32_t depth) : labelSet_(pg), depth_(depth) {}
+
+    ~CatchTable() = default;
+    NO_COPY_SEMANTIC(CatchTable);
+    NO_MOVE_SEMANTIC(CatchTable);
+
+    const TryLabelSet &LabelSet() const
+    {
+        return labelSet_;
+    }
+
+    uint32_t Depth() const
+    {
+        return depth_;
+    }
+
+private:
+    TryLabelSet labelSet_;
+    uint32_t depth_;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/base/condition.cpp b/es2panda/compiler/base/condition.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..644e9195fecef0aaa030ac05f26f19ebe9c77636
--- /dev/null
+++ b/es2panda/compiler/base/condition.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "condition.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/expressions/binaryExpression.h>
+#include <ir/expressions/unaryExpression.h>
+
+namespace panda::es2panda::compiler {
+
+void Condition::Compile(PandaGen *pg, const ir::Expression *expr, Label *falseLabel)
+{
+    if (expr->IsBinaryExpression()) {
+        const auto *binExpr = expr->AsBinaryExpression();
+
+        switch (binExpr->OperatorType()) {
+            case lexer::TokenType::PUNCTUATOR_EQUAL:
+            case lexer::TokenType::PUNCTUATOR_NOT_EQUAL:
+            case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL:
+            case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL:
+            case lexer::TokenType::PUNCTUATOR_LESS_THAN:
+            case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL:
+            case lexer::TokenType::PUNCTUATOR_GREATER_THAN:
+            case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL: {
+                // This is a special case
+                // These operators are expressed via cmp instructions and the following
+                // if-else branches. Condition also expressed via cmp instruction and
+                // the following if-else.
+                // the goal of this method is to merge these two sequences of instructions.
+                RegScope rs(pg);
+                VReg lhs = pg->AllocReg();
+
+                binExpr->Left()->Compile(pg);
+                pg->StoreAccumulator(binExpr, lhs);
+                binExpr->Right()->Compile(pg);
+                pg->Condition(binExpr, binExpr->OperatorType(), lhs, falseLabel);
+                return;
+            }
+            case lexer::TokenType::PUNCTUATOR_LOGICAL_AND: {
+                binExpr->Left()->Compile(pg);
+                pg->ToBoolean(binExpr);
+                pg->BranchIfFalse(binExpr, falseLabel);
+
+                binExpr->Right()->Compile(pg);
+                pg->ToBoolean(binExpr);
+                pg->BranchIfFalse(binExpr, falseLabel);
+                return;
+            }
+            case lexer::TokenType::PUNCTUATOR_LOGICAL_OR: {
+                auto *endLabel = pg->AllocLabel();
+
+                binExpr->Left()->Compile(pg);
+                pg->ToBoolean(binExpr);
+                pg->BranchIfTrue(binExpr, endLabel);
+
+                binExpr->Right()->Compile(pg);
+                pg->ToBoolean(binExpr);
+                pg->BranchIfFalse(binExpr, falseLabel);
+                pg->SetLabel(binExpr, endLabel);
+                return;
+            }
+            default: {
+                break;
+            }
+        }
+    } else if (expr->IsUnaryExpression() &&
+               expr->AsUnaryExpression()->OperatorType() == lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK) {
+        expr->AsUnaryExpression()->Argument()->Compile(pg);
+
+        pg->Negate(expr);
+        pg->BranchIfFalse(expr, falseLabel);
+        return;
+    }
+
+    // General case including some binExpr i.E.(a+b)
+    expr->Compile(pg);
+    pg->ToBoolean(expr);
+    pg->BranchIfFalse(expr, falseLabel);
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/condition.h b/es2panda/compiler/base/condition.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6ad51d835e7314bf0b1826ffdf414c889627db5
--- /dev/null
+++ b/es2panda/compiler/base/condition.h
@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_BASE_CONDITION_H
+#define ES2PANDA_COMPILER_BASE_CONDITION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+class Label;
+
+class Condition {
+public:
+    Condition() = delete;
+
+    static void Compile(PandaGen *pg, const ir::Expression *expr, Label *falseLabel);
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/base/destructuring.cpp b/es2panda/compiler/base/destructuring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ff756529f3b4f1b528f3245a35b19636af46963
--- /dev/null
+++ b/es2panda/compiler/base/destructuring.cpp
@@ -0,0 +1,262 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "destructuring.h"
+
+#include <util/helpers.h>
+#include <compiler/base/iterators.h>
+#include <compiler/base/lreference.h>
+#include <compiler/base/catchTable.h>
+#include <compiler/core/pandagen.h>
+#include <ir/base/property.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/objectExpression.h>
+
+namespace panda::es2panda::compiler {
+
+static void GenRestElement(PandaGen *pg, const ir::SpreadElement *restElement,
+                           const DestructuringIterator &destIterator, bool isDeclaration)
+{
+    VReg array = pg->AllocReg();
+    VReg index = pg->AllocReg();
+
+    auto *next = pg->AllocLabel();
+    auto *done = pg->AllocLabel();
+
+    DestructuringRestIterator iterator(destIterator);
+
+    // create left reference for rest element
+    LReference lref = LReference::CreateLRef(pg, restElement, isDeclaration);
+
+    // create an empty array first
+    pg->CreateEmptyArray(restElement);
+    pg->StoreAccumulator(restElement, array);
+
+    // index = 0
+    pg->LoadAccumulatorInt(restElement, 0);
+    pg->StoreAccumulator(restElement, index);
+
+    pg->SetLabel(restElement, next);
+
+    iterator.Step(done);
+    pg->StoreObjByValue(restElement, array, index);
+
+    // index++
+    pg->LoadAccumulatorInt(restElement, 1);
+    pg->Binary(restElement, lexer::TokenType::PUNCTUATOR_PLUS, index);
+    pg->StoreAccumulator(restElement, index);
+
+    pg->Branch(restElement, next);
+
+    pg->SetLabel(restElement, done);
+    pg->LoadAccumulator(restElement, array);
+
+    lref.SetValue();
+}
+
+static void GenArray(PandaGen *pg, const ir::ArrayExpression *array)
+{
+    // RegScope rs(pg);
+    DestructuringIterator iterator(pg, array);
+
+    if (array->Elements().empty()) {
+        iterator.Close(false);
+        return;
+    }
+
+    TryContext tryCtx(pg);
+    const auto &labelSet = tryCtx.LabelSet();
+    pg->SetLabel(array, labelSet.TryBegin());
+
+    for (const auto *element : array->Elements()) {
+        RegScope ers(pg);
+
+        if (element->IsRestElement()) {
+            GenRestElement(pg, element->AsRestElement(), iterator, array->IsDeclaration());
+            break;
+        }
+
+        // if a hole exist, just let the iterator step ahead
+        if (element->IsOmittedExpression()) {
+            iterator.Step();
+            continue;
+        }
+
+        const ir::Expression *init = nullptr;
+        const ir::Expression *target = element;
+
+        if (element->IsAssignmentPattern()) {
+            target = element->AsAssignmentPattern()->Left();
+            init = element->AsAssignmentPattern()->Right();
+        }
+
+        LReference lref = LReference::CreateLRef(pg, target, array->IsDeclaration());
+        iterator.Step();
+
+        if (init) {
+            auto *assingValue = pg->AllocLabel();
+            auto *defaultInit = pg->AllocLabel();
+            pg->BranchIfUndefined(element, defaultInit);
+            pg->LoadAccumulator(element, iterator.Result());
+            pg->Branch(element, assingValue);
+
+            pg->SetLabel(element, defaultInit);
+            init->Compile(pg);
+            pg->SetLabel(element, assingValue);
+        }
+
+        lref.SetValue();
+    }
+
+    pg->SetLabel(array, labelSet.TryEnd());
+
+    // Normal completion
+    pg->LoadAccumulator(array, iterator.Done());
+    pg->BranchIfTrue(array, labelSet.CatchEnd());
+    iterator.Close(false);
+
+    pg->Branch(array, labelSet.CatchEnd());
+
+    Label *end = pg->AllocLabel();
+    pg->SetLabel(array, labelSet.CatchBegin());
+    pg->StoreAccumulator(array, iterator.Result());
+    pg->LoadAccumulator(array, iterator.Done());
+
+    pg->BranchIfTrue(array, end);
+    pg->LoadAccumulator(array, iterator.Result());
+    iterator.Close(true);
+    pg->SetLabel(array, end);
+    pg->LoadAccumulator(array, iterator.Result());
+    pg->EmitThrow(array);
+    pg->SetLabel(array, labelSet.CatchEnd());
+}
+
+static void GenObjectProperty(PandaGen *pg, const ir::ObjectExpression *object, const ir::Expression *element,
+                              VReg value, VReg propReg)
+{
+    RegScope propScope(pg);
+    VReg loadedValue = pg->AllocReg();
+
+    const ir::Property *propExpr = element->AsProperty();
+
+    const ir::Expression *init = nullptr;
+    const ir::Expression *key = propExpr->Key();
+    const ir::Expression *target = propExpr->Value();
+
+    if (target->IsAssignmentPattern()) {
+        init = target->AsAssignmentPattern()->Right();
+        target = target->AsAssignmentPattern()->Left();
+    }
+
+    // compile key
+    if (key->IsIdentifier()) {
+        pg->LoadAccumulatorString(key, key->AsIdentifier()->Name());
+    } else {
+        key->Compile(pg);
+    }
+
+    pg->StoreAccumulator(key, propReg);
+
+    LReference lref = LReference::CreateLRef(pg, target, object->IsDeclaration());
+
+    // load obj property from rhs, return undefined if no corresponding property exists
+    pg->LoadObjByValue(element, value, propReg);
+    pg->StoreAccumulator(element, loadedValue);
+
+    if (init != nullptr) {
+        auto *getDefault = pg->AllocLabel();
+        auto *store = pg->AllocLabel();
+
+        pg->BranchIfUndefined(element, getDefault);
+        pg->LoadAccumulator(element, loadedValue);
+        pg->Branch(element, store);
+
+        // load default value
+        pg->SetLabel(element, getDefault);
+        init->Compile(pg);
+
+        pg->SetLabel(element, store);
+    }
+
+    lref.SetValue();
+}
+
+static void GenObjectWithRest(PandaGen *pg, const ir::ObjectExpression *object, VReg rhs)
+{
+    const auto &properties = object->Properties();
+
+    RegScope rs(pg);
+    VReg propStart = pg->NextReg();
+
+    for (const auto *element : properties) {
+        if (element->IsRestElement()) {
+            RegScope restScope(pg);
+            LReference lref = LReference::CreateLRef(pg, element, object->IsDeclaration());
+            pg->CreateObjectWithExcludedKeys(element, rhs, propStart, properties.size() - 1);
+            lref.SetValue();
+            break;
+        }
+
+        VReg propReg = pg->AllocReg();
+        GenObjectProperty(pg, object, element, rhs, propReg);
+    }
+}
+
+static void GenObject(PandaGen *pg, const ir::ObjectExpression *object, VReg rhs)
+{
+    const auto &properties = object->Properties();
+
+    if (properties.empty() || properties.back()->IsRestElement()) {
+        auto *notNullish = pg->AllocLabel();
+
+        pg->LoadAccumulator(object, rhs);
+        pg->BranchIfCoercible(object, notNullish);
+        pg->ThrowObjectNonCoercible(object);
+
+        pg->SetLabel(object, notNullish);
+
+        if (!properties.empty()) {
+            return GenObjectWithRest(pg, object, rhs);
+        }
+    }
+
+    for (const auto *element : properties) {
+        RegScope rs(pg);
+        VReg propReg = pg->AllocReg();
+
+        GenObjectProperty(pg, object, element, rhs, propReg);
+    }
+}
+
+void Destructuring::Compile(PandaGen *pg, const ir::Expression *pattern)
+{
+    RegScope rs(pg);
+
+    VReg rhs = pg->AllocReg();
+    pg->StoreAccumulator(pattern, rhs);
+
+    if (pattern->IsArrayPattern()) {
+        GenArray(pg, pattern->AsArrayPattern());
+    } else {
+        GenObject(pg, pattern->AsObjectPattern(), rhs);
+    }
+
+    pg->LoadAccumulator(pattern, rhs);
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/destructuring.h b/es2panda/compiler/base/destructuring.h
new file mode 100644
index 0000000000000000000000000000000000000000..081d7801b3d9415457ab05dd8605d258fc0f1d91
--- /dev/null
+++ b/es2panda/compiler/base/destructuring.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_BASE_DESTRUCTURING_H
+#define ES2PANDA_COMPILER_BASE_DESTRUCTURING_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class Destructuring {
+public:
+    Destructuring() = delete;
+
+    static void Compile(PandaGen *pg, const ir::Expression *pattern);
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/base/hoisting.cpp b/es2panda/compiler/base/hoisting.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..07621e8d630c5793019c81bf2641fc2da9f5b9e2
--- /dev/null
+++ b/es2panda/compiler/base/hoisting.cpp
@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "hoisting.h"
+
+#include <ir/base/scriptFunction.h>
+#include <binder/scope.h>
+#include <compiler/core/pandagen.h>
+
+namespace panda::es2panda::compiler {
+
+static void HoistVar(PandaGen *pg, binder::Variable *var, const binder::VarDecl *decl)
+{
+    auto *scope = pg->Scope();
+
+    if (scope->IsGlobalScope()) {
+        pg->LoadConst(decl->Node(), Constant::JS_UNDEFINED);
+        pg->StoreGlobalVar(decl->Node(), decl->Name());
+        return;
+    }
+
+    binder::ScopeFindResult result(decl->Name(), scope, 0, var);
+
+    pg->LoadConst(decl->Node(), Constant::JS_UNDEFINED);
+    pg->StoreAccToLexEnv(decl->Node(), result, true);
+}
+
+static void HoistFunction(PandaGen *pg, binder::Variable *var, const binder::FunctionDecl *decl)
+{
+    const ir::ScriptFunction *scriptFunction = decl->Node()->AsScriptFunction();
+    auto *scope = pg->Scope();
+
+    const auto &internalName = scriptFunction->Scope()->InternalName();
+
+    if (scope->IsGlobalScope()) {
+        pg->DefineFunction(decl->Node(), scriptFunction, internalName);
+        pg->StoreGlobalVar(decl->Node(), var->Declaration()->Name());
+        return;
+    }
+
+    ASSERT(scope->IsFunctionScope() || scope->IsCatchScope() || scope->IsLocalScope() || scope->IsModuleScope());
+    binder::ScopeFindResult result(decl->Name(), scope, 0, var);
+
+    pg->DefineFunction(decl->Node(), scriptFunction, internalName);
+    pg->StoreAccToLexEnv(decl->Node(), result, true);
+}
+
+void Hoisting::Hoist(PandaGen *pg)
+{
+    const auto *scope = pg->Scope();
+
+    for (const auto &[_, var] : scope->Bindings()) {
+        (void)_;
+        if (!var->HasFlag(binder::VariableFlags::HOIST)) {
+            continue;
+        }
+
+        const auto *decl = var->Declaration();
+
+        if (decl->IsVarDecl()) {
+            HoistVar(pg, var, decl->AsVarDecl());
+        } else {
+            ASSERT(decl->IsFunctionDecl());
+            HoistFunction(pg, var, decl->AsFunctionDecl());
+        }
+    }
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/hoisting.h b/es2panda/compiler/base/hoisting.h
new file mode 100644
index 0000000000000000000000000000000000000000..2448cf22281e170eda6c89b77aaea136c0f6804b
--- /dev/null
+++ b/es2panda/compiler/base/hoisting.h
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_BASE_HOISTING_H
+#define ES2PANDA_COMPILER_BASE_HOISTING_H
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class Hoisting {
+public:
+    static void Hoist(PandaGen *pg);
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/base/iterators.cpp b/es2panda/compiler/base/iterators.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1bf7ad888797b1fb5f2c829aab527b4979a09c8a
--- /dev/null
+++ b/es2panda/compiler/base/iterators.cpp
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "iterators.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/base/catchTable.h>
+#include <compiler/function/functionBuilder.h>
+
+namespace panda::es2panda::compiler {
+
+// Iterator
+
+Iterator::Iterator(PandaGen *pg, const ir::AstNode *node, IteratorType type)
+    : pg_(pg), node_(node), method_(pg->AllocReg()), iterator_(pg->AllocReg()), nextResult_(pg->AllocReg()), type_(type)
+{
+    if (type_ == IteratorType::ASYNC) {
+        pg_->GetAsyncIterator(node);
+    } else {
+        pg_->GetIterator(node);
+    }
+
+    pg_->StoreAccumulator(node, iterator_);
+    pg_->LoadObjByName(node_, iterator_, "next");
+    pg_->StoreAccumulator(node_, method_);
+
+    pg_->ThrowIfNotObject(node_);
+}
+
+void Iterator::GetMethod(util::StringView name) const
+{
+    pg_->GetMethod(node_, iterator_, name);
+    pg_->StoreAccumulator(node_, method_);
+}
+
+void Iterator::CallMethodWithValue() const
+{
+    pg_->CallThis(node_, method_, 2);
+}
+
+void Iterator::CallMethod() const
+{
+    pg_->CallThis(node_, method_, 1);
+}
+
+void Iterator::Next() const
+{
+    CallMethod();
+
+    if (type_ == IteratorType::ASYNC) {
+        pg_->FuncBuilder()->Await(node_);
+    }
+
+    pg_->ThrowIfNotObject(node_);
+    pg_->StoreAccumulator(node_, nextResult_);
+}
+
+void Iterator::Complete() const
+{
+    pg_->LoadObjByName(node_, nextResult_, "done");
+    pg_->ToBoolean(node_);
+}
+
+void Iterator::Value() const
+{
+    pg_->LoadObjByName(node_, nextResult_, "value");
+}
+
+void Iterator::Close(bool abruptCompletion) const
+{
+    if (type_ == IteratorType::SYNC) {
+        if (!abruptCompletion) {
+            pg_->LoadConst(node_, Constant::JS_HOLE);
+        }
+        pg_->CloseIterator(node_, iterator_);
+        return;
+    }
+
+    RegScope rs(pg_);
+    VReg completion = pg_->AllocReg();
+    VReg innerResult = pg_->AllocReg();
+    VReg innerResultType = pg_->AllocReg();
+
+    pg_->StoreAccumulator(node_, completion);
+    pg_->StoreConst(node_, innerResultType, Constant::JS_HOLE);
+
+    TryContext tryCtx(pg_);
+    const auto &labelSet = tryCtx.LabelSet();
+    Label *returnExits = pg_->AllocLabel();
+
+    pg_->SetLabel(node_, labelSet.TryBegin());
+
+    // 4. Let innerResult be GetMethod(iterator, "return").
+    GetMethod("return");
+
+    // 5. If innerResult.[[Type]] is normal, then
+    {
+        // b. If return is undefined, return Completion(completion).
+        pg_->BranchIfNotUndefined(node_, returnExits);
+        // a. Let return be innerResult.[[Value]].
+        pg_->LoadAccumulator(node_, completion);
+
+        if (abruptCompletion) {
+            pg_->EmitThrow(node_);
+        } else {
+            pg_->DirectReturn(node_);
+        }
+
+        pg_->SetLabel(node_, returnExits);
+
+        {
+            TryContext innerTryCtx(pg_);
+            const auto &innerLabelSet = innerTryCtx.LabelSet();
+
+            pg_->SetLabel(node_, innerLabelSet.TryBegin());
+            // c. Set innerResult to Call(return, iterator).
+            CallMethod();
+            // d. If innerResult.[[Type]] is normal, set innerResult to Await(innerResult.[[Value]]).
+            pg_->FuncBuilder()->Await(node_);
+            pg_->StoreAccumulator(node_, innerResult);
+            pg_->SetLabel(node_, innerLabelSet.TryEnd());
+            pg_->Branch(node_, innerLabelSet.CatchEnd());
+
+            pg_->SetLabel(node_, innerLabelSet.CatchBegin());
+            pg_->StoreAccumulator(node_, innerResult);
+            pg_->StoreAccumulator(node_, innerResultType);
+            pg_->SetLabel(node_, innerLabelSet.CatchEnd());
+        }
+    }
+
+    pg_->SetLabel(node_, labelSet.TryEnd());
+    pg_->Branch(node_, labelSet.CatchEnd());
+
+    pg_->SetLabel(node_, labelSet.CatchBegin());
+    pg_->StoreAccumulator(node_, innerResult);
+    pg_->StoreAccumulator(node_, innerResultType);
+    pg_->SetLabel(node_, labelSet.CatchEnd());
+
+    // 6. If completion.[[Type]] is throw, return Completion(completion).
+    if (abruptCompletion) {
+        pg_->LoadAccumulator(node_, completion);
+        pg_->EmitThrow(node_);
+    } else {
+        // 7. If innerResult.[[Type]] is throw, return Completion(innerResult).
+        pg_->LoadAccumulator(node_, innerResultType);
+        pg_->EmitRethrow(node_);
+    }
+
+    // 8. If Type(innerResult.[[Value]]) is not Object, throw a TypeError exception.
+    pg_->LoadAccumulator(node_, innerResult);
+    pg_->ThrowIfNotObject(node_);
+}
+
+DestructuringIterator::DestructuringIterator(PandaGen *pg, const ir::AstNode *node)
+    : Iterator(pg, node, IteratorType::SYNC), done_(pg->AllocReg()), result_(pg->AllocReg())
+{
+    pg_->StoreConst(node, done_, Constant::JS_FALSE);
+    pg_->StoreConst(node, result_, Constant::JS_UNDEFINED);
+}
+
+void DestructuringIterator::Step(Label *doneTarget) const
+{
+    TryContext tryCtx(pg_);
+    const auto &labelSet = tryCtx.LabelSet();
+    Label *normalClose = pg_->AllocLabel();
+    Label *noClose = pg_->AllocLabel();
+
+    pg_->SetLabel(node_, labelSet.TryBegin());
+    Next();
+    Complete();
+    pg_->StoreAccumulator(node_, done_);
+    pg_->BranchIfFalse(node_, normalClose);
+    pg_->StoreConst(node_, done_, Constant::JS_TRUE);
+    pg_->LoadConst(node_, Constant::JS_UNDEFINED);
+    OnIterDone(doneTarget);
+    pg_->Branch(node_, noClose);
+
+    pg_->SetLabel(node_, normalClose);
+    Value();
+    pg_->StoreAccumulator(node_, result_);
+    pg_->SetLabel(node_, noClose);
+
+    pg_->SetLabel(node_, labelSet.TryEnd());
+    pg_->Branch(node_, labelSet.CatchEnd());
+
+    pg_->SetLabel(node_, labelSet.CatchBegin());
+    pg_->StoreAccumulator(node_, result_);
+    pg_->StoreConst(node_, done_, Constant::JS_TRUE);
+    pg_->LoadAccumulator(node_, result_);
+    pg_->EmitThrow(node_);
+    pg_->SetLabel(node_, labelSet.CatchEnd());
+}
+
+void DestructuringIterator::OnIterDone([[maybe_unused]] Label *doneTarget) const
+{
+    pg_->LoadConst(node_, Constant::JS_UNDEFINED);
+}
+
+void DestructuringRestIterator::OnIterDone([[maybe_unused]] Label *doneTarget) const
+{
+    pg_->Branch(node_, doneTarget);
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/iterators.h b/es2panda/compiler/base/iterators.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f23818d9ed2015bc8db01e274ba63b5a064dea1
--- /dev/null
+++ b/es2panda/compiler/base/iterators.h
@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_BASE_ITERATORS_H
+#define ES2PANDA_COMPILER_BASE_ITERATORS_H
+
+#include <ir/irnode.h>
+
+namespace panda::es2panda::ir {
+class AstNode;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+enum class IteratorType { SYNC, ASYNC };
+
+class Iterator {
+public:
+    Iterator(PandaGen *pg, const ir::AstNode *node, IteratorType type);
+    DEFAULT_COPY_SEMANTIC(Iterator);
+    DEFAULT_MOVE_SEMANTIC(Iterator);
+    ~Iterator() = default;
+
+    IteratorType Type() const
+    {
+        return type_;
+    }
+
+    VReg Method() const
+    {
+        return method_;
+    }
+
+    VReg NextResult() const
+    {
+        return nextResult_;
+    }
+
+    const ir::AstNode *Node() const
+    {
+        return node_;
+    }
+
+    void GetMethod(util::StringView name) const;
+    void CallMethod() const;
+    void CallMethodWithValue() const;
+
+    void Next() const;
+    void Complete() const;
+    void Value() const;
+    void Close(bool abruptCompletion) const;
+
+protected:
+    PandaGen *pg_;
+    const ir::AstNode *node_;
+    // These 3 regs must be allocated continously
+    VReg method_;
+    VReg iterator_;
+    VReg nextResult_;
+    IteratorType type_;
+};
+
+class DestructuringIterator : public Iterator {
+public:
+    explicit DestructuringIterator(PandaGen *pg, const ir::AstNode *node);
+
+    DEFAULT_COPY_SEMANTIC(DestructuringIterator);
+    DEFAULT_MOVE_SEMANTIC(DestructuringIterator);
+    ~DestructuringIterator() = default;
+
+    VReg Done() const
+    {
+        return done_;
+    }
+
+    VReg Result() const
+    {
+        return result_;
+    }
+
+    void Step(Label *doneTarget = nullptr) const;
+
+    virtual void OnIterDone([[maybe_unused]] Label *doneTarget) const;
+
+    friend class DestructuringRestIterator;
+
+protected:
+    VReg done_;
+    VReg result_;
+};
+
+class DestructuringRestIterator : public DestructuringIterator {
+public:
+    explicit DestructuringRestIterator(const DestructuringIterator &iterator) : DestructuringIterator(iterator) {}
+
+    DEFAULT_COPY_SEMANTIC(DestructuringRestIterator);
+    DEFAULT_MOVE_SEMANTIC(DestructuringRestIterator);
+    ~DestructuringRestIterator() = default;
+
+    void OnIterDone([[maybe_unused]] Label *doneTarget) const override;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/base/lexenv.cpp b/es2panda/compiler/base/lexenv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3410f06c2ff81e8e0a5a098f5909111720f2970
--- /dev/null
+++ b/es2panda/compiler/base/lexenv.cpp
@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "lexenv.h"
+
+#include <binder/variable.h>
+#include <compiler/core/envScope.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/moduleContext.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::compiler {
+
+// Helpers
+
+static bool CheckTdz(const ir::AstNode *node)
+{
+    return node->IsIdentifier() && node->AsIdentifier()->IsTdz();
+}
+
+static void CheckConstAssignment(PandaGen *pg, const ir::AstNode *node, binder::Variable *variable)
+{
+    if (!variable->Declaration()->IsConstDecl()) {
+        return;
+    }
+
+    pg->ThrowConstAssignment(node, variable->Name());
+}
+
+// VirtualLoadVar
+
+static void ExpandLoadLexVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
+{
+    pg->LoadLexicalVar(node, result.lexLevel, result.variable->AsLocalVariable()->LexIdx());
+    pg->ThrowUndefinedIfHole(node, result.variable->Name());
+}
+
+static void ExpandLoadNormalVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
+{
+    auto *local = result.variable->AsLocalVariable();
+
+    if (CheckTdz(node)) {
+        pg->LoadConst(node, Constant::JS_HOLE);
+        pg->ThrowUndefinedIfHole(node, local->Name());
+    } else {
+        pg->LoadAccumulator(node, local->Vreg());
+    }
+}
+
+void VirtualLoadVar::Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
+{
+    if (result.variable->LexicalBound()) {
+        ExpandLoadLexVar(pg, node, result);
+    } else {
+        ExpandLoadNormalVar(pg, node, result);
+    }
+}
+
+// VirtualStoreVar
+
+static void StoreLocalExport(PandaGen *pg, const ir::AstNode *node, binder::Variable *variable)
+{
+    if (!variable->HasFlag(binder::VariableFlags::LOCAL_EXPORT) || !pg->Scope()->IsModuleScope()) {
+        return;
+    }
+
+    auto range = pg->Scope()->AsModuleScope()->LocalExports().equal_range(variable);
+
+    for (auto it = range.first; it != range.second; ++it) {
+        if (it->second != "default") {
+            pg->StoreModuleVar(node, it->second);
+        }
+    }
+}
+
+static void ExpandStoreLexVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDecl)
+{
+    binder::LocalVariable *local = result.variable->AsLocalVariable();
+
+    const auto *decl = result.variable->Declaration();
+
+    if (decl->IsLetOrConstDecl() && !isDecl) {
+        RegScope rs(pg);
+
+        VReg valueReg = pg->AllocReg();
+        pg->StoreAccumulator(node, valueReg);
+
+        ExpandLoadLexVar(pg, node, result);
+
+        if (decl->IsConstDecl()) {
+            pg->ThrowConstAssignment(node, local->Name());
+        }
+
+        pg->LoadAccumulator(node, valueReg);
+    }
+
+    pg->StoreLexicalVar(node, result.lexLevel, local->LexIdx());
+
+    StoreLocalExport(pg, node, local);
+}
+
+static void ExpandStoreNormalVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result,
+                                 bool isDecl)
+{
+    auto *local = result.variable->AsLocalVariable();
+    VReg localReg = local->Vreg();
+
+    if (!isDecl) {
+        if (CheckTdz(node)) {
+            pg->LoadConst(node, Constant::JS_HOLE);
+            pg->ThrowUndefinedIfHole(node, local->Name());
+        }
+
+        CheckConstAssignment(pg, node, local);
+    }
+
+    pg->StoreAccumulator(node, localReg);
+    StoreLocalExport(pg, node, local);
+}
+
+void VirtualStoreVar::Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDecl)
+{
+    if (result.variable->LexicalBound()) {
+        ExpandStoreLexVar(pg, node, result, isDecl);
+    } else {
+        ExpandStoreNormalVar(pg, node, result, isDecl);
+    }
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/lexenv.h b/es2panda/compiler/base/lexenv.h
new file mode 100644
index 0000000000000000000000000000000000000000..128b8c45791cdabfad19d5672b6b744af7fd365c
--- /dev/null
+++ b/es2panda/compiler/base/lexenv.h
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_SCOPES_LEXENV_H
+#define ES2PANDA_COMPILER_SCOPES_LEXENV_H
+
+#include <binder/scope.h>
+#include <ir/irnode.h>
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class VirtualLoadVar {
+public:
+    VirtualLoadVar() = delete;
+
+    static void Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result);
+};
+
+class VirtualStoreVar {
+public:
+    VirtualStoreVar() = delete;
+
+    static void Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDecl);
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/base/literals.cpp b/es2panda/compiler/base/literals.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0690bb6602f2737e4568ab5dc1f3b9fad29f758f
--- /dev/null
+++ b/es2panda/compiler/base/literals.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "literals.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/base/templateElement.h>
+#include <ir/expressions/taggedTemplateExpression.h>
+#include <ir/expressions/templateLiteral.h>
+
+namespace panda::es2panda::compiler {
+
+// Literals
+
+void Literals::GetTemplateObject(PandaGen *pg, const ir::TaggedTemplateExpression *lit)
+{
+    RegScope rs(pg);
+    VReg templateArg = pg->AllocReg();
+    VReg indexReg = pg->AllocReg();
+    VReg rawArr = pg->AllocReg();
+    VReg cookedArr = pg->AllocReg();
+
+    const ir::TemplateLiteral *templateLit = lit->Quasi();
+
+    pg->CreateEmptyArray(templateLit);
+    pg->StoreAccumulator(templateLit, rawArr);
+
+    pg->CreateEmptyArray(templateLit);
+    pg->StoreAccumulator(templateLit, cookedArr);
+
+    size_t elemIndex = 0;
+
+    for (const auto *element : templateLit->Quasis()) {
+        pg->LoadAccumulatorInt(element, elemIndex);
+        pg->StoreAccumulator(element, indexReg);
+
+        pg->LoadAccumulatorString(element, element->Raw());
+        pg->StoreObjByValue(element, rawArr, indexReg);
+
+        pg->LoadAccumulatorString(element, element->Cooked());
+        pg->StoreObjByValue(element, cookedArr, indexReg);
+
+        elemIndex++;
+    }
+
+    pg->CreateEmptyArray(lit);
+    pg->StoreAccumulator(lit, templateArg);
+
+    elemIndex = 0;
+    pg->LoadAccumulatorInt(lit, elemIndex);
+    pg->StoreAccumulator(lit, indexReg);
+
+    pg->LoadAccumulator(lit, rawArr);
+    pg->StoreObjByValue(lit, templateArg, indexReg);
+
+    elemIndex++;
+    pg->LoadAccumulatorInt(lit, elemIndex);
+    pg->StoreAccumulator(lit, indexReg);
+
+    pg->LoadAccumulator(lit, cookedArr);
+    pg->StoreObjByValue(lit, templateArg, indexReg);
+
+    pg->GetTemplateObject(lit, templateArg);
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/literals.h b/es2panda/compiler/base/literals.h
new file mode 100644
index 0000000000000000000000000000000000000000..ddda8fc23861ab1be8805d722dbca9ed12cce94c
--- /dev/null
+++ b/es2panda/compiler/base/literals.h
@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_BASE_LITERALS_H
+#define ES2PANDA_COMPILER_BASE_LITERALS_H
+
+#include <ir/expressions/literal.h>
+#include <util/ustring.h>
+
+#include <variant>
+
+namespace panda::es2panda::ir {
+class Literal;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class LiteralBuffer {
+public:
+    explicit LiteralBuffer(ArenaAllocator *allocator) : literals_(allocator->Adapter()) {}
+    ~LiteralBuffer() = default;
+    NO_COPY_SEMANTIC(LiteralBuffer);
+    NO_MOVE_SEMANTIC(LiteralBuffer);
+
+    void Add(ir::Literal *lit)
+    {
+        literals_.push_back(lit);
+    }
+
+    bool IsEmpty() const
+    {
+        return literals_.empty();
+    }
+
+    size_t Size() const
+    {
+        return literals_.size();
+    }
+
+    int32_t Index() const
+    {
+        return index_;
+    }
+
+    void ResetLiteral(size_t index, const ir::Literal *literal)
+    {
+        literals_[index] = literal;
+    }
+
+    const ArenaVector<const ir::Literal *> &Literals() const
+    {
+        return literals_;
+    }
+
+    void Insert(LiteralBuffer *other)
+    {
+        literals_.insert(literals_.end(), other->literals_.begin(), other->literals_.end());
+        other->literals_.clear();
+    }
+
+    void SetIndex(int32_t index)
+    {
+        index_ = index;
+    }
+
+private:
+    ArenaVector<const ir::Literal *> literals_;
+    int32_t index_ {};
+};
+
+class Literals {
+public:
+    Literals() = delete;
+
+    static void GetTemplateObject(PandaGen *pg, const ir::TaggedTemplateExpression *lit);
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/base/lreference.cpp b/es2panda/compiler/base/lreference.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6fd21e14eedd2b4be322b5746b6411bd6f70a279
--- /dev/null
+++ b/es2panda/compiler/base/lreference.cpp
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "lreference.h"
+
+#include <binder/declaration.h>
+#include <compiler/base/destructuring.h>
+#include <compiler/core/pandagen.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/statements/variableDeclaration.h>
+#include <ir/statements/variableDeclarator.h>
+
+namespace panda::es2panda::compiler {
+
+// LReference
+
+LReference::LReference(const ir::AstNode *node, PandaGen *pg, bool isDeclaration, ReferenceKind refKind,
+                       binder::ScopeFindResult res)
+    : node_(node), pg_(pg), refKind_(refKind), res_(res), isDeclaration_(isDeclaration)
+{
+    if (refKind == ReferenceKind::MEMBER) {
+        obj_ = pg_->AllocReg();
+
+        node_->AsMemberExpression()->CompileObject(pg_, obj_);
+        prop_ = node->AsMemberExpression()->CompileKey(pg_);
+    }
+}
+
+void LReference::GetValue()
+{
+    switch (refKind_) {
+        case ReferenceKind::VAR_OR_GLOBAL: {
+            pg_->LoadVar(node_->AsIdentifier(), res_);
+            break;
+        }
+        case ReferenceKind::MEMBER: {
+            pg_->LoadObjProperty(node_, obj_, prop_);
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+void LReference::SetValue()
+{
+    switch (refKind_) {
+        case ReferenceKind::VAR_OR_GLOBAL: {
+            pg_->StoreVar(node_, res_, isDeclaration_);
+            break;
+        }
+        case ReferenceKind::MEMBER: {
+            if (node_->AsMemberExpression()->Object()->IsSuperExpression()) {
+                pg_->StoreSuperProperty(node_, obj_, prop_);
+            } else {
+                pg_->StoreObjProperty(node_, obj_, prop_);
+            }
+
+            break;
+        }
+        case ReferenceKind::DESTRUCTURING: {
+            Destructuring::Compile(pg_, node_->AsExpression());
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+ReferenceKind LReference::Kind() const
+{
+    return refKind_;
+}
+
+binder::Variable *LReference::Variable() const
+{
+    return res_.variable;
+}
+
+LReference LReference::CreateLRef(PandaGen *pg, const ir::AstNode *node, bool isDeclaration)
+{
+    switch (node->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            const util::StringView &name = node->AsIdentifier()->Name();
+            binder::ScopeFindResult res = pg->Scope()->Find(name);
+
+            return {node, pg, isDeclaration, ReferenceKind::VAR_OR_GLOBAL, res};
+        }
+        case ir::AstNodeType::MEMBER_EXPRESSION: {
+            return {node, pg, false, ReferenceKind::MEMBER, {}};
+        }
+        case ir::AstNodeType::VARIABLE_DECLARATION: {
+            ASSERT(node->AsVariableDeclaration()->Declarators().size() == 1);
+            return LReference::CreateLRef(pg, node->AsVariableDeclaration()->Declarators()[0]->Id(), true);
+        }
+        case ir::AstNodeType::VARIABLE_DECLARATOR: {
+            return LReference::CreateLRef(pg, node->AsVariableDeclarator()->Id(), true);
+        }
+        case ir::AstNodeType::ARRAY_PATTERN:
+        case ir::AstNodeType::OBJECT_PATTERN: {
+            return {node, pg, isDeclaration, ReferenceKind::DESTRUCTURING, {}};
+        }
+        case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+            return LReference::CreateLRef(pg, node->AsAssignmentPattern()->Left(), true);
+        }
+        case ir::AstNodeType::REST_ELEMENT: {
+            return LReference::CreateLRef(pg, node->AsRestElement()->Argument(), true);
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/base/lreference.h b/es2panda/compiler/base/lreference.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7edf06f7b90d4f08a94bce2f7faaa85dea5c880
--- /dev/null
+++ b/es2panda/compiler/base/lreference.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_BASE_LREFERENCE_H
+#define ES2PANDA_COMPILER_BASE_LREFERENCE_H
+
+#include <binder/scope.h>
+#include <ir/irnode.h>
+
+namespace panda::es2panda::ir {
+class AstNode;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+enum class ReferenceKind {
+    MEMBER,
+    VAR_OR_GLOBAL,
+    DESTRUCTURING,
+};
+
+enum class ReferenceFlags {
+    NONE = 0,
+    DECLARATION = 1U << 0U,
+};
+
+class PandaGen;
+
+class LReference {
+public:
+    LReference(const ir::AstNode *node, PandaGen *pg, bool isDeclaration, ReferenceKind refKind,
+               binder::ScopeFindResult res);
+    ~LReference() = default;
+    NO_COPY_SEMANTIC(LReference);
+    NO_MOVE_SEMANTIC(LReference);
+
+    void GetValue();
+    void SetValue();
+    binder::Variable *Variable() const;
+    ReferenceKind Kind() const;
+
+    static LReference CreateLRef(PandaGen *pg, const ir::AstNode *node, bool isDeclaration);
+
+private:
+    const ir::AstNode *node_;
+    PandaGen *pg_;
+    ReferenceKind refKind_;
+    binder::ScopeFindResult res_;
+    VReg obj_;
+    Operand prop_;
+    bool isDeclaration_;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/compileQueue.cpp b/es2panda/compiler/core/compileQueue.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29460a7b3b4a59143e2c994747b7587c334251af
--- /dev/null
+++ b/es2panda/compiler/core/compileQueue.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "compileQueue.h"
+
+#include <binder/binder.h>
+#include <binder/scope.h>
+#include <compiler/core/compilerContext.h>
+#include <compiler/core/emitter.h>
+#include <compiler/core/function.h>
+#include <compiler/core/pandagen.h>
+
+namespace panda::es2panda::compiler {
+
+void CompileJob::Run()
+{
+    std::unique_lock<std::mutex> lock(m_);
+    cond_.wait(lock, [this] { return dependencies_ == 0; });
+
+    ArenaAllocator allocator(SpaceType::SPACE_TYPE_COMPILER, nullptr, true);
+    PandaGen pg(&allocator, context_, scope_);
+
+    Function::Compile(&pg);
+
+    FunctionEmitter funcEmitter(&allocator, &pg);
+    funcEmitter.Generate();
+
+    context_->GetEmitter()->AddFunction(&funcEmitter);
+
+    if (dependant_) {
+        dependant_->Signal();
+    }
+}
+
+void CompileJob::DependsOn(CompileJob *job)
+{
+    job->dependant_ = this;
+    dependencies_++;
+}
+
+void CompileJob::Signal()
+{
+    {
+        std::lock_guard<std::mutex> lock(m_);
+        dependencies_--;
+    }
+
+    cond_.notify_one();
+}
+
+CompileQueue::CompileQueue(size_t threadCount)
+{
+    threads_.reserve(threadCount);
+
+    for (size_t i = 0; i < threadCount; i++) {
+        threads_.push_back(os::thread::ThreadStart(Worker, this));
+    }
+}
+
+CompileQueue::~CompileQueue()
+{
+    void *retval = nullptr;
+
+    std::unique_lock<std::mutex> lock(m_);
+    terminate_ = true;
+    lock.unlock();
+    jobsAvailable_.notify_all();
+
+    for (const auto handle_id : threads_) {
+        os::thread::ThreadJoin(handle_id, &retval);
+    }
+}
+
+void CompileQueue::Schedule(CompilerContext *context)
+{
+    ASSERT(jobsCount_ == 0);
+    std::unique_lock<std::mutex> lock(m_);
+    const auto &functions = context->Binder()->Functions();
+    jobs_ = new CompileJob[functions.size()]();
+
+    for (auto *function : functions) {
+        jobs_[jobsCount_++].SetConext(context, function);
+    }
+
+    lock.unlock();
+    jobsAvailable_.notify_all();
+}
+
+void CompileQueue::Worker(CompileQueue *queue)
+{
+    while (true) {
+        std::unique_lock<std::mutex> lock(queue->m_);
+        queue->jobsAvailable_.wait(lock, [queue]() { return queue->terminate_ || queue->jobsCount_ != 0; });
+
+        if (queue->terminate_) {
+            return;
+        }
+
+        lock.unlock();
+
+        queue->Consume();
+        queue->jobsFinished_.notify_one();
+    }
+}
+
+void CompileQueue::Consume()
+{
+    std::unique_lock<std::mutex> lock(m_);
+    activeWorkers_++;
+
+    while (jobsCount_ > 0) {
+        --jobsCount_;
+        auto &job = jobs_[jobsCount_];
+
+        lock.unlock();
+
+        try {
+            job.Run();
+        } catch (const Error &e) {
+            lock.lock();
+            errors_.push_back(e);
+            lock.unlock();
+        }
+
+        lock.lock();
+    }
+
+    activeWorkers_--;
+}
+
+void CompileQueue::Wait()
+{
+    std::unique_lock<std::mutex> lock(m_);
+    jobsFinished_.wait(lock, [this]() { return activeWorkers_ == 0 && jobsCount_ == 0; });
+    delete[] jobs_;
+
+    if (!errors_.empty()) {
+        // NOLINTNEXTLINE
+        throw errors_.front();
+    }
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/compileQueue.h b/es2panda/compiler/core/compileQueue.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e227475ba26c314078b5d5f4108a8b5c069ee63
--- /dev/null
+++ b/es2panda/compiler/core/compileQueue.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_COMPILEQUEUE_H
+#define ES2PANDA_COMPILER_CORE_COMPILEQUEUE_H
+
+#include <macros.h>
+#include <os/thread.h>
+#include <es2panda.h>
+
+#include <condition_variable>
+#include <mutex>
+
+namespace panda::es2panda::binder {
+class FunctionScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+
+class CompilerContext;
+
+class CompileJob {
+public:
+    CompileJob() = default;
+    NO_COPY_SEMANTIC(CompileJob);
+    NO_MOVE_SEMANTIC(CompileJob);
+    ~CompileJob() = default;
+
+    binder::FunctionScope *Scope() const
+    {
+        return scope_;
+    }
+
+    void SetConext(CompilerContext *context, binder::FunctionScope *scope)
+    {
+        context_ = context;
+        scope_ = scope;
+    }
+
+    void Run();
+    void DependsOn(CompileJob *job);
+    void Signal();
+
+private:
+    std::mutex m_;
+    std::condition_variable cond_;
+    CompilerContext *context_ {};
+    binder::FunctionScope *scope_ {};
+    CompileJob *dependant_ {};
+    size_t dependencies_ {0};
+};
+
+class CompileQueue {
+public:
+    explicit CompileQueue(size_t threadCount);
+    NO_COPY_SEMANTIC(CompileQueue);
+    NO_MOVE_SEMANTIC(CompileQueue);
+    ~CompileQueue();
+
+    void Schedule(CompilerContext *context);
+    void Consume();
+    void Wait();
+
+private:
+    static void Worker(CompileQueue *queue);
+
+    std::vector<os::thread::native_handle_type> threads_;
+    std::vector<Error> errors_;
+    std::mutex m_;
+    std::condition_variable jobsAvailable_;
+    std::condition_variable jobsFinished_;
+    CompileJob *jobs_ {};
+    size_t jobsCount_ {0};
+    size_t activeWorkers_ {0};
+    bool terminate_ {false};
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/compilerContext.cpp b/es2panda/compiler/core/compilerContext.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a97c410fdd32e9a6b48274c4700ec069553893c
--- /dev/null
+++ b/es2panda/compiler/core/compilerContext.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "compilerContext.h"
+
+#include <compiler/core/emitter.h>
+
+namespace panda::es2panda::compiler {
+
+CompilerContext::CompilerContext(binder::Binder *binder, bool isDebug)
+    : binder_(binder), emitter_(std::make_unique<class Emitter>(this)), isDebug_(isDebug)
+{
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/compilerContext.h b/es2panda/compiler/core/compilerContext.h
new file mode 100644
index 0000000000000000000000000000000000000000..517163ae62d861c45600c38321c9780a62103e3a
--- /dev/null
+++ b/es2panda/compiler/core/compilerContext.h
@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_COMPILER_CONTEXT_H
+#define ES2PANDA_COMPILER_CORE_COMPILER_CONTEXT_H
+
+#include <macros.h>
+#include <mem/arena_allocator.h>
+
+#include <cstdint>
+#include <mutex>
+
+namespace panda::es2panda::binder {
+class Binder;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+
+class DebugInfo;
+class Emitter;
+
+class CompilerContext {
+public:
+    CompilerContext(binder::Binder *binder, bool isDebug);
+    NO_COPY_SEMANTIC(CompilerContext);
+    NO_MOVE_SEMANTIC(CompilerContext);
+    ~CompilerContext() = default;
+
+    binder::Binder *Binder() const
+    {
+        return binder_;
+    }
+
+    Emitter *GetEmitter() const
+    {
+        return emitter_.get();
+    }
+
+    int32_t LiteralCount() const
+    {
+        return literalBufferIdx_;
+    }
+
+    int32_t NewLiteralIndex()
+    {
+        std::lock_guard lock(m_);
+        return literalBufferIdx_++;
+    }
+
+    std::mutex &Mutex()
+    {
+        return m_;
+    }
+
+    bool IsDebug() const
+    {
+        return isDebug_;
+    }
+
+private:
+    binder::Binder *binder_;
+    std::unique_ptr<Emitter> emitter_;
+    int32_t literalBufferIdx_ {0};
+    std::mutex m_;
+    bool isDebug_;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/compilerImpl.cpp b/es2panda/compiler/core/compilerImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4ff569b2a7da04f7405cbb0f76ded8ea043606e
--- /dev/null
+++ b/es2panda/compiler/core/compilerImpl.cpp
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "compilerImpl.h"
+
+#include <compiler/core/compileQueue.h>
+#include <compiler/core/compilerContext.h>
+#include <compiler/core/emitter.h>
+#include <typescript/checker.h>
+#include <es2panda.h>
+#include <parser/program/program.h>
+
+#include <iostream>
+#include <thread>
+
+namespace panda::es2panda::compiler {
+
+CompilerImpl::CompilerImpl(size_t threadCount) : queue_(new CompileQueue(threadCount)) {}
+
+CompilerImpl::~CompilerImpl()
+{
+    delete queue_;
+}
+
+panda::pandasm::Program *CompilerImpl::Compile(parser::Program *program, const es2panda::CompilerOptions &options)
+{
+    CompilerContext context(program->Binder(), options.isDebug);
+
+    if (program->Extension() == ScriptExtension::TS) {
+        ArenaAllocator localAllocator(SpaceType::SPACE_TYPE_COMPILER, nullptr, true);
+        auto checker = std::make_unique<checker::Checker>(&localAllocator, context.Binder());
+        checker->StartChecker();
+
+        /* TODO(): TS files are not yet compiled */
+        return nullptr;
+    }
+
+    queue_->Schedule(&context);
+
+    /* Main thread can also be used instead of idling */
+    queue_->Consume();
+    queue_->Wait();
+
+    return context.GetEmitter()->Finalize(options.dumpDebugInfo);
+}
+
+void CompilerImpl::DumpAsm(const panda::pandasm::Program *prog)
+{
+    Emitter::DumpAsm(prog);
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/compilerImpl.h b/es2panda/compiler/core/compilerImpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..19c6061347f643e46a5de26d170a800251e019ce
--- /dev/null
+++ b/es2panda/compiler/core/compilerImpl.h
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_INCLUDE_COMPILER_IMPL_H
+#define ES2PANDA_COMPILER_INCLUDE_COMPILER_IMPL_H
+
+#include <es2panda.h>
+#include <macros.h>
+#include <mem/arena_allocator.h>
+#include <os/thread.h>
+
+#include <string>
+
+namespace panda::pandasm {
+struct Program;
+}  // namespace panda::pandasm
+
+namespace panda::es2panda::parser {
+class Program;
+}  // namespace panda::es2panda::parser
+
+namespace panda::es2panda::compiler {
+class CompileQueue;
+
+class CompilerImpl {
+public:
+    explicit CompilerImpl(size_t threadCount);
+    ~CompilerImpl();
+    NO_COPY_SEMANTIC(CompilerImpl);
+    NO_MOVE_SEMANTIC(CompilerImpl);
+
+    panda::pandasm::Program *Compile(parser::Program *program, const es2panda::CompilerOptions &options);
+    static void DumpAsm(const panda::pandasm::Program *prog);
+
+private:
+    CompileQueue *queue_;
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/dynamicContext.cpp b/es2panda/compiler/core/dynamicContext.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..73e9e9ddcb08b589c09a48c9d822fe1497086fb4
--- /dev/null
+++ b/es2panda/compiler/core/dynamicContext.cpp
@@ -0,0 +1,178 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dynamicContext.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/base/catchTable.h>
+#include <ir/expressions/identifier.h>
+#include <ir/statements/tryStatement.h>
+#include <ir/statements/blockStatement.h>
+#include <ir/statements/labelledStatement.h>
+
+namespace panda::es2panda::compiler {
+DynamicContext::DynamicContext(PandaGen *pg, LabelTarget target) : pg_(pg), target_(target), prev_(pg_->dynamicContext_)
+{
+    pg_->dynamicContext_ = this;
+}
+
+DynamicContext::~DynamicContext()
+{
+    pg_->dynamicContext_ = prev_;
+}
+
+LabelContext::LabelContext(PandaGen *pg, const ir::LabelledStatement *labelledStmt)
+    : DynamicContext(pg, LabelTarget(labelledStmt->Ident()->Name())), labelledStmt_(labelledStmt)
+{
+    if (!labelledStmt->Body()->IsBlockStatement()) {
+        return;
+    }
+
+    label_ = pg->AllocLabel();
+    target_.SetBreakTarget(label_);
+}
+
+LabelContext::~LabelContext()
+{
+    if (!label_) {
+        return;
+    }
+
+    pg_->SetLabel(labelledStmt_, label_);
+}
+
+LexEnvContext::LexEnvContext(LoopEnvScope *envScope, PandaGen *pg, LabelTarget target)
+    : DynamicContext(pg, target), envScope_(envScope)
+{
+    if (!envScope_->HasEnv()) {
+        return;
+    }
+
+    catchTable_ = pg_->CreateCatchTable();
+    const auto &labelSet = catchTable_->LabelSet();
+    const auto *node = envScope_->Scope()->Node();
+
+    pg_->SetLabel(node, labelSet.TryBegin());
+}
+
+LexEnvContext::~LexEnvContext()
+{
+    if (!envScope_->HasEnv()) {
+        return;
+    }
+
+    const auto &labelSet = catchTable_->LabelSet();
+    const auto *node = envScope_->Scope()->Node();
+
+    pg_->SetLabel(node, labelSet.TryEnd());
+    pg_->Branch(node, labelSet.CatchEnd());
+
+    pg_->SetLabel(node, labelSet.CatchBegin());
+    pg_->PopLexEnv(node);
+    pg_->EmitThrow(node);
+    pg_->SetLabel(node, labelSet.CatchEnd());
+    pg_->PopLexEnv(node);
+}
+
+bool LexEnvContext::HasTryCatch() const
+{
+    return envScope_->HasEnv();
+}
+
+void LexEnvContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                                 [[maybe_unused]] const util::StringView &targetLabel)
+{
+    if (cfc == ControlFlowChange::CONTINUE || !envScope_->HasEnv()) {
+        return;
+    }
+
+    const auto *node = envScope_->Scope()->Node();
+    pg_->PopLexEnv(node);
+}
+
+IteratorContext::IteratorContext(PandaGen *pg, const Iterator &iterator, LabelTarget target)
+    : DynamicContext(pg, target), iterator_(iterator), catchTable_(pg->CreateCatchTable())
+{
+    const auto &labelSet = catchTable_->LabelSet();
+    pg_->SetLabel(iterator_.Node(), labelSet.TryBegin());
+}
+
+IteratorContext::~IteratorContext()
+{
+    const auto &labelSet = catchTable_->LabelSet();
+    const auto *node = iterator_.Node();
+
+    pg_->SetLabel(node, labelSet.TryEnd());
+    pg_->Branch(node, labelSet.CatchEnd());
+
+    pg_->SetLabel(node, labelSet.CatchBegin());
+    iterator_.Close(true);
+    pg_->SetLabel(node, labelSet.CatchEnd());
+}
+
+void IteratorContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                                   [[maybe_unused]] const util::StringView &targetLabel)
+{
+    if (cfc == ControlFlowChange::CONTINUE && target_.ContinueLabel() == targetLabel) {
+        return;
+    }
+
+    iterator_.Close(false);
+}
+
+void TryContext::InitFinalizer()
+{
+    ASSERT(tryStmt_);
+
+    if (!hasFinalizer_ || !tryStmt_->FinallyBlock()) {
+        return;
+    }
+
+    finalizerRun_ = pg_->AllocReg();
+    pg_->StoreConst(tryStmt_, finalizerRun_, Constant::JS_UNDEFINED);
+}
+
+void TryContext::InitCatchTable()
+{
+    catchTable_ = pg_->CreateCatchTable();
+}
+
+const TryLabelSet &TryContext::LabelSet() const
+{
+    return catchTable_->LabelSet();
+}
+
+bool TryContext::HasFinalizer() const
+{
+    return hasFinalizer_;
+}
+
+void TryContext::EmitFinalizer()
+{
+    if (!hasFinalizer_ || inFinalizer_ || !tryStmt_->FinallyBlock()) {
+        return;
+    }
+
+    inFinalizer_ = true;
+    tryStmt_->FinallyBlock()->Compile(pg_);
+    inFinalizer_ = false;
+}
+
+void TryContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                              [[maybe_unused]] const util::StringView &targetLabel)
+{
+    EmitFinalizer();
+}
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/dynamicContext.h b/es2panda/compiler/core/dynamicContext.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e13faab6e9ab022393fa06168150f4af0fa2590
--- /dev/null
+++ b/es2panda/compiler/core/dynamicContext.h
@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_DYNAMIC_CONTEXT_H
+#define ES2PANDA_COMPILER_CORE_DYNAMIC_CONTEXT_H
+
+#include <util/ustring.h>
+#include <ir/irnode.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/base/iterators.h>
+
+namespace panda::es2panda::ir {
+class TryStatement;
+class ForOfStatement;
+class LabelledStatement;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+class LoopEnvScope;
+class CatchTable;
+class TryLabelSet;
+
+enum class DynamicContextType { NONE, LABEL, LEX_ENV, ITERATOR, TRY };
+
+class DynamicContext {
+public:
+    NO_COPY_SEMANTIC(DynamicContext);
+    NO_MOVE_SEMANTIC(DynamicContext);
+    ~DynamicContext();
+
+    void *operator new(size_t) = delete;
+    void *operator new[](size_t) = delete;
+
+    virtual void AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                              [[maybe_unused]] const util::StringView &targetLabel) {};
+
+    virtual bool HasTryCatch() const
+    {
+        return false;
+    }
+
+    virtual bool HasFinalizer() const
+    {
+        return HasTryCatch();
+    }
+
+    virtual DynamicContextType Type() const = 0;
+
+    DynamicContext *Prev()
+    {
+        return prev_;
+    }
+
+    const DynamicContext *Prev() const
+    {
+        return prev_;
+    }
+
+    const LabelTarget &Target() const
+    {
+        return target_;
+    }
+
+protected:
+    explicit DynamicContext(PandaGen *pg, LabelTarget target);
+
+    PandaGen *pg_;
+    LabelTarget target_;
+    DynamicContext *prev_ {};
+};
+
+class LabelContext : public DynamicContext {
+public:
+    explicit LabelContext(PandaGen *pg, LabelTarget target) : DynamicContext(pg, target) {}
+    explicit LabelContext(PandaGen *pg, const ir::LabelledStatement *labelledStmt);
+    NO_COPY_SEMANTIC(LabelContext);
+    NO_MOVE_SEMANTIC(LabelContext);
+    ~LabelContext();
+
+    DynamicContextType Type() const override
+    {
+        return DynamicContextType::LABEL;
+    }
+
+private:
+    Label *label_ {};
+    const ir::LabelledStatement *labelledStmt_ {};
+};
+
+class LexEnvContext : public DynamicContext {
+public:
+    explicit LexEnvContext(LoopEnvScope *envScope, PandaGen *pg, LabelTarget target);
+    NO_COPY_SEMANTIC(LexEnvContext);
+    NO_MOVE_SEMANTIC(LexEnvContext);
+    ~LexEnvContext();
+
+    DynamicContextType Type() const override
+    {
+        return DynamicContextType::LEX_ENV;
+    }
+
+    bool HasTryCatch() const override;
+    void AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                      [[maybe_unused]] const util::StringView &targetLabel) override;
+
+private:
+    LoopEnvScope *envScope_;
+    CatchTable *catchTable_ {};
+};
+
+class IteratorContext : public DynamicContext {
+public:
+    explicit IteratorContext(PandaGen *pg, const Iterator &iterator, LabelTarget target);
+    NO_COPY_SEMANTIC(IteratorContext);
+    NO_MOVE_SEMANTIC(IteratorContext);
+    ~IteratorContext();
+
+    DynamicContextType Type() const override
+    {
+        return DynamicContextType::ITERATOR;
+    }
+
+    const Iterator &GetIterator() const
+    {
+        return iterator_;
+    }
+
+    bool HasTryCatch() const override
+    {
+        return true;
+    }
+
+    void AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                      [[maybe_unused]] const util::StringView &targetLabel) override;
+
+private:
+    const Iterator &iterator_;
+    CatchTable *catchTable_;
+};
+
+class TryContext : public DynamicContext {
+public:
+    explicit TryContext(PandaGen *pg, const ir::TryStatement *tryStmt, bool hasFinalizer = true)
+        : DynamicContext(pg, {}), tryStmt_(tryStmt), hasFinalizer_(hasFinalizer)
+    {
+        InitCatchTable();
+        InitFinalizer();
+    }
+
+    explicit TryContext(PandaGen *pg) : DynamicContext(pg, {})
+    {
+        InitCatchTable();
+    }
+
+    NO_COPY_SEMANTIC(TryContext);
+    NO_MOVE_SEMANTIC(TryContext);
+    ~TryContext() = default;
+
+    DynamicContextType Type() const override
+    {
+        return DynamicContextType::TRY;
+    }
+
+    bool HasTryCatch() const override
+    {
+        return true;
+    }
+
+    VReg FinalizerRun() const
+    {
+        return finalizerRun_;
+    }
+
+    CatchTable *GetCatchTable() const
+    {
+        return catchTable_;
+    }
+
+    const TryLabelSet &LabelSet() const;
+    bool HasFinalizer() const override;
+    void InitFinalizer();
+    void EmitFinalizer();
+
+    void AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                      [[maybe_unused]] const util::StringView &targetLabel) override;
+
+private:
+    void InitCatchTable();
+
+    const ir::TryStatement *tryStmt_ {};
+    CatchTable *catchTable_ {};
+    VReg finalizerRun_ {};
+    bool hasFinalizer_ {};
+    bool inFinalizer_ {};
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/emitter.cpp b/es2panda/compiler/core/emitter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e617cb41f196d3b1ae3fdc361eed462f28af155
--- /dev/null
+++ b/es2panda/compiler/core/emitter.cpp
@@ -0,0 +1,446 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "emitter.h"
+
+#include <binder/binder.h>
+#include <util/helpers.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <compiler/base/literals.h>
+#include <compiler/core/compilerContext.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/debugger/debuginfoDumper.h>
+#include <compiler/base/catchTable.h>
+#include <es2panda.h>
+#include <gen/isa.h>
+#include <ir/expressions/literal.h>
+#include <ir/statements/blockStatement.h>
+#include <macros.h>
+#include <parser/program/program.h>
+
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <utility>
+
+namespace panda::es2panda::compiler {
+
+constexpr const auto LANG_EXT = panda::pandasm::extensions::Language::ECMASCRIPT;
+
+FunctionEmitter::FunctionEmitter(ArenaAllocator *allocator, const PandaGen *pg)
+    : pg_(pg), literalBuffers_(allocator->Adapter())
+{
+    func_ = allocator->New<panda::pandasm::Function>(pg->InternalName().Mutf8(), LANG_EXT);
+
+    size_t paramCount = pg->InternalParamCount();
+    func_->params.reserve(paramCount);
+
+    for (uint32_t i = 0; i < paramCount; ++i) {
+        func_->params.emplace_back(panda::pandasm::Type("any", 0), LANG_EXT);
+    }
+
+    func_->regs_num = pg->TotalRegsNum();
+    func_->return_type = panda::pandasm::Type("any", 0);
+}
+
+void FunctionEmitter::Generate()
+{
+    GenFunctionInstructions();
+    GenVariablesDebugInfo();
+    GenSourceFileDebugInfo();
+    GenFunctionCatchTables();
+    GenFunctionICSize();
+    GenLiteralBuffers();
+}
+
+const ArenaSet<util::StringView> &FunctionEmitter::Strings() const
+{
+    return pg_->Strings();
+}
+
+void FunctionEmitter::GenBufferLiterals(const LiteralBuffer *buff)
+{
+    auto &[idx, array] = literalBuffers_.emplace_back();
+    idx = buff->Index();
+    array.reserve(buff->Literals().size() * 2);
+
+    for (const auto *literal : buff->Literals()) {
+        panda::pandasm::LiteralArray::Literal valueLit;
+        panda::pandasm::LiteralArray::Literal tagLit;
+
+        ir::LiteralTag tag = literal->Tag();
+
+        switch (tag) {
+            case ir::LiteralTag::BOOLEAN: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::BOOL;
+                valueLit.value_ = literal->GetBoolean();
+                break;
+            }
+            case ir::LiteralTag::INTEGER: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::INTEGER;
+                valueLit.value_ = literal->GetInt();
+                break;
+            }
+            case ir::LiteralTag::DOUBLE: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::DOUBLE;
+                valueLit.value_ = literal->GetDouble();
+                break;
+            }
+            case ir::LiteralTag::STRING: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::STRING;
+                valueLit.value_ = literal->GetString().Mutf8();
+                break;
+            }
+            case ir::LiteralTag::ACCESSOR: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::ACCESSOR;
+                valueLit.value_ = static_cast<uint8_t>(0);
+                break;
+            }
+            case ir::LiteralTag::METHOD: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::METHOD;
+                valueLit.value_ = literal->GetMethod().Mutf8();
+                break;
+            }
+            case ir::LiteralTag::GENERATOR_METHOD: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::GENERATORMETHOD;
+                valueLit.value_ = literal->GetMethod().Mutf8();
+                break;
+            }
+            case ir::LiteralTag::ASYNC_GENERATOR_METHOD: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::ASYNCGENERATORMETHOD;
+                valueLit.value_ = literal->GetMethod().Mutf8();
+                break;
+            }
+            case ir::LiteralTag::NULL_VALUE: {
+                valueLit.tag_ = panda::panda_file::LiteralTag::NULLVALUE;
+                valueLit.value_ = static_cast<uint8_t>(0);
+                break;
+            }
+            default:
+                break;
+        }
+
+        tagLit.tag_ = panda::panda_file::LiteralTag::TAGVALUE;
+        tagLit.value_ = static_cast<uint8_t>(valueLit.tag_);
+
+        array.emplace_back(tagLit);
+        array.emplace_back(valueLit);
+    }
+}
+
+util::StringView FunctionEmitter::SourceCode() const
+{
+    return pg_->Binder()->Program()->SourceCode();
+}
+
+static Format MatchFormat(const IRNode *node, const Formats &formats)
+{
+    std::array<const VReg *, IRNode::MAX_REG_OPERAND> regs {};
+    auto regCnt = node->Registers(&regs);
+    auto registers = Span<const VReg *>(regs.data(), regs.data() + regCnt);
+
+    const auto *iter = formats.begin();
+
+    for (; iter != formats.end(); iter++) {
+        auto format = *iter;
+        size_t limit = 0;
+        for (const auto &formatItem : format.GetFormatItem()) {
+            if (formatItem.IsVReg()) {
+                limit = 1 << formatItem.Bitwidth();
+                break;
+            }
+        }
+
+        if (std::all_of(registers.begin(), registers.end(), [limit](const VReg *reg) { return *reg < limit; })) {
+            return format;
+        }
+    }
+
+    UNREACHABLE();
+    return *iter;
+}
+
+static size_t GetIRNodeWholeLength(const IRNode *node)
+{
+    Formats formats = node->GetFormats();
+    if (formats.empty()) {
+        return 0;
+    }
+
+    size_t len = 1;
+    const auto format = MatchFormat(node, formats);
+
+    for (auto fi : format.GetFormatItem()) {
+        len += fi.Bitwidth() / 8;
+    }
+
+    return len;
+}
+
+static std::string WholeLine(const util::StringView &source, lexer::SourceRange range)
+{
+    return source.Substr(range.start.index, range.end.index).EscapeSymbol<util::StringView::Mutf8Encode>();
+}
+
+void FunctionEmitter::GenInstructionDebugInfo(const IRNode *ins, panda::pandasm::Ins *pandaIns)
+{
+    const ir::AstNode *astNode = ins->Node();
+
+    ASSERT(astNode != nullptr);
+
+    if (astNode == FIRST_NODE_OF_FUNCTION) {
+        astNode = pg_->Debuginfo().firstStmt;
+        if (!astNode) {
+            return;
+        }
+    }
+
+    pandaIns->ins_debug.line_number = astNode->Range().start.line + 1;
+
+    if (pg_->IsDebug()) {
+        size_t insLen = GetIRNodeWholeLength(ins);
+        if (insLen != 0) {
+            pandaIns->ins_debug.bound_left = offset_;
+            pandaIns->ins_debug.bound_right = offset_ + insLen;
+        }
+
+        offset_ += insLen;
+        pandaIns->ins_debug.whole_line = WholeLine(SourceCode(), astNode->Range());
+    }
+}
+
+void FunctionEmitter::GenFunctionInstructions()
+{
+    func_->ins.reserve(pg_->Insns().size());
+
+    for (const auto *ins : pg_->Insns()) {
+        auto &pandaIns = func_->ins.emplace_back();
+
+        ins->Transform(&pandaIns);
+        GenInstructionDebugInfo(ins, &pandaIns);
+    }
+}
+
+void FunctionEmitter::GenFunctionICSize()
+{
+    panda::pandasm::AnnotationData funcAnnotationData("_ESAnnotation");
+    panda::pandasm::AnnotationElement icSizeAnnotationElement(
+        "icSize", std::make_unique<panda::pandasm::ScalarValue>(
+                      panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::U32>(pg_->IcSize())));
+    funcAnnotationData.AddElement(std::move(icSizeAnnotationElement));
+
+    panda::pandasm::AnnotationElement parameterLengthAnnotationElement(
+        "parameterLength",
+        std::make_unique<panda::pandasm::ScalarValue>(
+            panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::U32>(pg_->FormalParametersCount())));
+    funcAnnotationData.AddElement(std::move(parameterLengthAnnotationElement));
+
+    panda::pandasm::AnnotationElement funcNameAnnotationElement(
+        "funcName",
+        std::make_unique<panda::pandasm::ScalarValue>(
+            panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::STRING>(pg_->FunctionName().Mutf8())));
+    funcAnnotationData.AddElement(std::move(funcNameAnnotationElement));
+
+    func_->metadata->AddAnnotations({funcAnnotationData});
+}
+
+void FunctionEmitter::GenFunctionCatchTables()
+{
+    func_->catch_blocks.reserve(pg_->CatchList().size());
+
+    for (const auto *catchBlock : pg_->CatchList()) {
+        const auto &labelSet = catchBlock->LabelSet();
+
+        auto &pandaCatchBlock = func_->catch_blocks.emplace_back();
+        pandaCatchBlock.try_begin_label = labelSet.TryBegin()->Id();
+        pandaCatchBlock.try_end_label = labelSet.TryEnd()->Id();
+        pandaCatchBlock.catch_begin_label = labelSet.CatchBegin()->Id();
+        pandaCatchBlock.catch_end_label = labelSet.CatchEnd()->Id();
+    }
+}
+
+void FunctionEmitter::GenLiteralBuffers()
+{
+    for (const auto *buff : pg_->BuffStorage()) {
+        GenBufferLiterals(buff);
+    }
+}
+
+void FunctionEmitter::GenSourceFileDebugInfo()
+{
+    func_->source_file = std::string {pg_->Binder()->Program()->SourceFile()};
+
+    if (!pg_->IsDebug()) {
+        return;
+    }
+
+    if (pg_->RootNode()->IsProgram()) {
+        func_->source_code = SourceCode().EscapeSymbol<util::StringView::Mutf8Encode>();
+    }
+}
+
+void FunctionEmitter::GenScopeVariableInfo(const binder::Scope *scope)
+{
+    const auto *startIns = scope->ScopeStart();
+    const auto *endIns = scope->ScopeEnd();
+
+    uint32_t start = 0;
+    uint32_t count = 0;
+
+    for (const auto *it : pg_->Insns()) {
+        if (startIns == it) {
+            start = count;
+        } else if (endIns == it) {
+            auto varsLength = static_cast<uint32_t>(count - start + 1);
+
+            for (const auto &[name, variable] : scope->Bindings()) {
+                if (!variable->IsLocalVariable() || variable->LexicalBound()) {
+                    continue;
+                }
+
+                auto &variableDebug = func_->local_variable_debug.emplace_back();
+                variableDebug.name = name.Mutf8();
+                variableDebug.signature = "any";
+                variableDebug.signature_type = "any";
+                variableDebug.reg = static_cast<int32_t>(variable->AsLocalVariable()->Vreg());
+                variableDebug.start = start;
+                variableDebug.length = static_cast<uint32_t>(varsLength);
+            }
+
+            break;
+        }
+
+        count++;
+    }
+}
+
+void FunctionEmitter::GenVariablesDebugInfo()
+{
+    if (!pg_->IsDebug()) {
+        return;
+    }
+
+    for (const auto *scope : pg_->Debuginfo().variableDebugInfo) {
+        GenScopeVariableInfo(scope);
+    }
+}
+
+// Emitter
+
+Emitter::Emitter(const CompilerContext *context)
+{
+    prog_ = new panda::pandasm::Program();
+    prog_->lang = panda::pandasm::extensions::Language::ECMASCRIPT;
+
+    prog_->function_table.reserve(context->Binder()->Functions().size());
+    GenESAnnoatationRecord();
+    GenESModuleModeRecord(context->Binder()->Program()->Kind() == parser::ScriptKind::MODULE);
+}
+
+Emitter::~Emitter()
+{
+    delete prog_;
+}
+
+void Emitter::GenESAnnoatationRecord()
+{
+    auto annotationRecord = panda::pandasm::Record("_ESAnnotation", LANG_EXT);
+    annotationRecord.metadata->SetAttribute("external");
+    annotationRecord.metadata->SetAccessFlags(panda::ACC_ANNOTATION);
+    prog_->record_table.emplace(annotationRecord.name, std::move(annotationRecord));
+}
+
+void Emitter::GenESModuleModeRecord(bool isModule)
+{
+    auto modeRecord = panda::pandasm::Record("_ESModuleMode", LANG_EXT);
+    modeRecord.metadata->SetAccessFlags(panda::ACC_PUBLIC);
+
+    auto modeField = panda::pandasm::Field(LANG_EXT);
+    modeField.name = "isModule";
+    modeField.type = panda::pandasm::Type("u8", 0);
+    modeField.metadata->SetValue(
+        panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::U8>(static_cast<uint8_t>(isModule)));
+
+    modeRecord.field_list.emplace_back(std::move(modeField));
+
+    prog_->record_table.emplace(modeRecord.name, std::move(modeRecord));
+}
+
+void Emitter::AddFunction(FunctionEmitter *func)
+{
+    std::lock_guard<std::mutex> lock(m_);
+
+    for (const auto &str : func->Strings()) {
+        prog_->strings.insert(str.Mutf8());
+    }
+
+    for (auto &[idx, buf] : func->LiteralBuffers()) {
+        auto literalArrayInstance = panda::pandasm::LiteralArray(std::move(buf));
+        prog_->literalarray_table.emplace(std::to_string(idx), std::move(literalArrayInstance));
+    }
+
+    auto *function = func->Function();
+    prog_->function_table.emplace(function->name, std::move(*function));
+}
+
+void Emitter::DumpAsm(const panda::pandasm::Program *prog)
+{
+    auto &ss = std::cout;
+
+    ss << ".language ECMAScript" << std::endl << std::endl;
+
+    for (auto &[name, func] : prog->function_table) {
+        ss << ".function any " << name << '(';
+
+        for (uint32_t i = 0; i < func.GetParamsNum(); i++) {
+            ss << "any a" << std::to_string(i);
+
+            if (i != func.GetParamsNum() - 1) {
+                ss << ", ";
+            }
+        }
+
+        ss << ") {" << std::endl;
+
+        for (const auto &ins : func.ins) {
+            ss << (ins.set_label ? "" : "\t") << ins.ToString("", true, func.GetTotalRegs()) << std::endl;
+        }
+
+        ss << "}" << std::endl << std::endl;
+
+        for (const auto &ct : func.catch_blocks) {
+            ss << ".catchall " << ct.try_begin_label << ", " << ct.try_end_label << ", " << ct.catch_begin_label
+               << std::endl
+               << std::endl;
+        }
+    }
+
+    ss << std::endl;
+}
+
+panda::pandasm::Program *Emitter::Finalize(bool dumpDebugInfo)
+{
+    if (dumpDebugInfo) {
+        debuginfo::DebugInfoDumper dumper(prog_);
+        dumper.Dump();
+    }
+
+    auto *prog = prog_;
+    prog_ = nullptr;
+    return prog;
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/emitter.h b/es2panda/compiler/core/emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..addf4b142b4daaeb21c86c5edcf424de01ea2c0b
--- /dev/null
+++ b/es2panda/compiler/core/emitter.h
@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_IR_EMITTER_H
+#define ES2PANDA_COMPILER_IR_EMITTER_H
+
+#include <assembly-literals.h>
+#include <ir/astNode.h>
+#include <lexer/token/sourceLocation.h>
+#include <macros.h>
+#include <util/ustring.h>
+
+#include <list>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace panda::pandasm {
+struct Program;
+struct Function;
+struct Ins;
+}  // namespace panda::pandasm
+
+namespace panda::es2panda::ir {
+class Statement;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::binder {
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+class LiteralBuffer;
+class DebugInfo;
+class Label;
+class IRNode;
+class CompilerContext;
+
+class FunctionEmitter {
+public:
+    explicit FunctionEmitter(ArenaAllocator *allocator, const PandaGen *pg);
+    ~FunctionEmitter() = default;
+    NO_COPY_SEMANTIC(FunctionEmitter);
+    NO_MOVE_SEMANTIC(FunctionEmitter);
+
+    panda::pandasm::Function *Function()
+    {
+        return func_;
+    }
+
+    auto &LiteralBuffers()
+    {
+        return literalBuffers_;
+    }
+
+    void Generate();
+    const ArenaSet<util::StringView> &Strings() const;
+
+private:
+    void GenInstructionDebugInfo(const IRNode *ins, panda::pandasm::Ins *pandaIns);
+    void GenFunctionInstructions();
+    void GenFunctionCatchTables();
+    void GenFunctionICSize();
+    void GenScopeVariableInfo(const binder::Scope *scope);
+    void GenSourceFileDebugInfo();
+    void GenVariablesDebugInfo();
+    util::StringView SourceCode() const;
+
+    void GenLiteralBuffers();
+    void GenBufferLiterals(const LiteralBuffer *buff);
+
+    const PandaGen *pg_;
+    panda::pandasm::Function *func_ {};
+    ArenaVector<std::pair<int32_t, std::vector<panda::pandasm::LiteralArray::Literal>>> literalBuffers_;
+    size_t offset_ {0};
+};
+
+class Emitter {
+public:
+    explicit Emitter(const CompilerContext *context);
+    ~Emitter();
+    NO_COPY_SEMANTIC(Emitter);
+    NO_MOVE_SEMANTIC(Emitter);
+
+    void AddFunction(FunctionEmitter *func);
+    static void DumpAsm(const panda::pandasm::Program *prog);
+    panda::pandasm::Program *Finalize(bool dumpDebugInfo);
+
+private:
+    void GenESAnnoatationRecord();
+    void GenESModuleModeRecord(bool isModule);
+
+    std::mutex m_;
+    panda::pandasm::Program *prog_;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/envScope.cpp b/es2panda/compiler/core/envScope.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e2fa13c78c7038bb1a0d4e2a0eb7405af141868
--- /dev/null
+++ b/es2panda/compiler/core/envScope.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "envScope.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+
+ScopeContext::ScopeContext(PandaGen *pg, binder::Scope *newScope) : pg_(pg), prevScope_(pg_->scope_)
+{
+    pg_->scope_ = newScope;
+}
+
+ScopeContext::~ScopeContext()
+{
+    pg_->scope_ = prevScope_;
+}
+
+void EnvScope::Initialize(PandaGen *pg, VReg lexEnv)
+{
+    pg_ = pg;
+    prev_ = pg_->envScope_;
+    lexEnv_ = lexEnv;
+    pg_->envScope_ = this;
+}
+
+EnvScope::~EnvScope()
+{
+    if (!pg_) {
+        return;
+    }
+
+    pg_->envScope_ = prev_;
+}
+
+void LoopEnvScope::CopyBindings(PandaGen *pg, binder::VariableScope *scope, binder::VariableFlags flag)
+{
+    if (!HasEnv()) {
+        return;
+    }
+
+    Initialize(pg, pg->AllocReg());
+
+    pg_->NewLexEnv(scope_->Node(), scope->LexicalSlots());
+    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
+
+    ASSERT(scope->NeedLexEnv());
+
+    for (const auto &[_, variable] : scope_->Bindings()) {
+        (void)_;
+        if (!variable->HasFlag(flag)) {
+            continue;
+        }
+
+        pg->LoadLexicalVar(scope_->Node(), 1, variable->AsLocalVariable()->LexIdx());
+        pg->StoreLexicalVar(scope_->Parent()->Node(), 0, variable->AsLocalVariable()->LexIdx());
+    }
+}
+
+void LoopEnvScope::CopyPetIterationCtx()
+{
+    if (!HasEnv()) {
+        return;
+    }
+
+    pg_->CopyLexEnv(scope_->Node());
+    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/envScope.h b/es2panda/compiler/core/envScope.h
new file mode 100644
index 0000000000000000000000000000000000000000..55b801a7a1f3e026a9403344d896fdbedc68ecbe
--- /dev/null
+++ b/es2panda/compiler/core/envScope.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_ENV_SCOPE_H
+#define ES2PANDA_COMPILER_CORE_ENV_SCOPE_H
+
+#include <binder/scope.h>
+#include <ir/irnode.h>
+#include <compiler/core/dynamicContext.h>
+#include <compiler/core/regScope.h>
+#include <compiler/core/labelTarget.h>
+
+namespace panda::es2panda::ir {
+class AstNode;
+class Statement;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class ScopeContext {
+public:
+    explicit ScopeContext(PandaGen *pg, binder::Scope *newScope);
+    ~ScopeContext();
+
+    NO_COPY_SEMANTIC(ScopeContext);
+    NO_MOVE_SEMANTIC(ScopeContext);
+
+private:
+    PandaGen *pg_;
+    binder::Scope *prevScope_;
+};
+
+class EnvScope {
+public:
+    explicit EnvScope() = default;
+
+    NO_COPY_SEMANTIC(EnvScope);
+    NO_MOVE_SEMANTIC(EnvScope);
+    ~EnvScope();
+
+    void Initialize(PandaGen *pg, VReg lexEnv);
+
+    VReg LexEnv() const
+    {
+        return lexEnv_;
+    }
+
+    EnvScope *Prev() const
+    {
+        return prev_;
+    }
+
+protected:
+    friend class PandaGen;
+
+    PandaGen *pg_ {};
+    EnvScope *prev_ {};
+    VReg lexEnv_ {};
+};
+
+class LoopEnvScope : public EnvScope {
+public:
+    explicit LoopEnvScope(PandaGen *pg, binder::LoopScope *scope, LabelTarget target)
+        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg, scope), lexEnvCtx_(this, pg, target)
+    {
+        CopyBindings(pg, scope, binder::VariableFlags::PER_ITERATION);
+    }
+
+    explicit LoopEnvScope(PandaGen *pg, LabelTarget target, binder::LoopScope *scope)
+        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg), lexEnvCtx_(this, pg, target)
+    {
+        CopyBindings(pg, scope, binder::VariableFlags::PER_ITERATION);
+    }
+
+    explicit LoopEnvScope(PandaGen *pg, binder::LoopDeclarationScope *scope)
+        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg), lexEnvCtx_(this, pg, {})
+    {
+        CopyBindings(pg, scope, binder::VariableFlags::LOOP_DECL);
+    }
+
+    binder::VariableScope *Scope() const
+    {
+        ASSERT(HasEnv());
+        return scope_;
+    }
+
+    bool HasEnv() const
+    {
+        return scope_ != nullptr;
+    }
+
+    void CopyPetIterationCtx();
+
+private:
+    static bool NeedEnv(binder::VariableScope *scope)
+    {
+        return scope->IsVariableScope() && scope->AsVariableScope()->NeedLexEnv();
+    }
+
+    void CopyBindings(PandaGen *pg, binder::VariableScope *scope, binder::VariableFlags flag);
+
+    binder::VariableScope *scope_ {};
+    LocalRegScope regScope_;
+    LexEnvContext lexEnvCtx_;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/function.cpp b/es2panda/compiler/core/function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8625e3f28155c571f83e1abbde96feac25844436
--- /dev/null
+++ b/es2panda/compiler/core/function.cpp
@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "function.h"
+
+#include <binder/binder.h>
+#include <util/helpers.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <compiler/base/lreference.h>
+#include <compiler/core/pandagen.h>
+#include <ir/base/classDefinition.h>
+#include <ir/base/classProperty.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/statements/blockStatement.h>
+
+namespace panda::es2panda::compiler {
+
+static void CompileSourceBlock(PandaGen *pg, const ir::BlockStatement *block)
+{
+    bool hasReturn = false;
+
+    const auto &statements = block->Statements();
+    pg->SetFirstStmt(statements.empty() ? block : statements.front());
+
+    for (const auto *stmt : statements) {
+        stmt->Compile(pg);
+
+        if (stmt->IsReturnStatement()) {
+            hasReturn = true;
+        }
+    }
+
+    if (hasReturn) {
+        return;
+    }
+
+    pg->ImplicitReturn(statements.empty() ? block : statements.back());
+}
+
+static void CompileFunctionParameterDeclaration(PandaGen *pg, const ir::ScriptFunction *func)
+{
+    ScopeContext scopeCtx(pg, func->Scope()->ParamScope());
+
+    uint32_t index = 0;
+
+    for (const auto *param : func->Params()) {
+        LReference ref = LReference::CreateLRef(pg, param, true);
+
+        [[maybe_unused]] binder::Variable *paramVar = ref.Variable();
+
+        if (ref.Kind() == ReferenceKind::DESTRUCTURING) {
+            util::StringView name = util::Helpers::ToStringView(pg->Allocator(), index);
+            paramVar = pg->Scope()->FindLocal(name, binder::ResolveBindingOptions::BINDINGS);
+        }
+
+        ASSERT(paramVar && paramVar->IsLocalVariable());
+
+        VReg paramReg = binder::Binder::MANDATORY_PARAMS_NUMBER + index++;
+        ASSERT(paramVar->LexicalBound() || paramVar->AsLocalVariable()->Vreg() == paramReg);
+
+        if (param->IsAssignmentPattern()) {
+            RegScope rs(pg);
+            pg->LoadAccumulator(func, paramReg);
+            auto *nonDefaultLabel = pg->AllocLabel();
+
+            if (ref.Kind() == ReferenceKind::DESTRUCTURING) {
+                auto *loadParamLabel = pg->AllocLabel();
+
+                pg->BranchIfNotUndefined(func, loadParamLabel);
+                param->AsAssignmentPattern()->Right()->Compile(pg);
+                pg->Branch(func, nonDefaultLabel);
+
+                pg->SetLabel(func, loadParamLabel);
+                pg->LoadAccumulator(func, paramReg);
+
+                pg->SetLabel(func, nonDefaultLabel);
+                ref.SetValue();
+            } else {
+                pg->BranchIfNotUndefined(func, nonDefaultLabel);
+
+                param->AsAssignmentPattern()->Right()->Compile(pg);
+                ref.SetValue();
+                pg->SetLabel(func, nonDefaultLabel);
+            }
+
+            continue;
+        }
+
+        if (param->IsRestElement()) {
+            pg->CopyRestArgs(param, func->Params().size() - 1);
+        } else if (ref.Kind() == ReferenceKind::DESTRUCTURING) {
+            pg->LoadAccumulator(func, paramReg);
+        } else {
+            continue;
+        }
+        ref.SetValue();
+    }
+}
+
+static void CompileInstanceFields(PandaGen *pg, const ir::ScriptFunction *decl)
+{
+    const auto &statements = decl->Parent()->Parent()->Parent()->AsClassDefinition()->Body();
+
+    RegScope rs(pg);
+    auto thisReg = pg->AllocReg();
+    pg->GetThis(decl);
+    pg->StoreAccumulator(decl, thisReg);
+
+    for (auto const &stmt : statements) {
+        if (stmt->IsClassProperty()) {
+            const auto *prop = stmt->AsClassProperty();
+            if (!prop->Value()) {
+                pg->LoadConst(stmt, Constant::JS_UNDEFINED);
+            } else {
+                RegScope rsProp(pg);
+                prop->Value()->Compile(pg);
+            }
+
+            if (!prop->Key()->IsIdentifier()) {
+                PandaGen::Unimplemented();
+            }
+
+            pg->StoreObjByName(stmt, thisReg, prop->Key()->AsIdentifier()->Name());
+        }
+    }
+}
+
+static void CompileFunction(PandaGen *pg)
+{
+    const auto *decl = pg->RootNode()->AsScriptFunction();
+
+    // TODO(szilagyia): move after super call
+    if (decl->IsConstructor()) {
+        CompileInstanceFields(pg, decl);
+    }
+
+    auto *funcParamScope = pg->TopScope()->ParamScope();
+    if (funcParamScope->NameVar()) {
+        RegScope rs(pg);
+        pg->GetFunctionObject(pg->RootNode());
+        pg->StoreAccToLexEnv(pg->RootNode(), funcParamScope->Find(funcParamScope->NameVar()->Name()), true);
+    }
+
+    CompileFunctionParameterDeclaration(pg, decl);
+
+    pg->FunctionEnter();
+    const ir::AstNode *body = decl->Body();
+
+    if (body->IsExpression()) {
+        body->Compile(pg);
+        pg->DirectReturn(decl);
+    } else {
+        CompileSourceBlock(pg, body->AsBlockStatement());
+    }
+
+    pg->FunctionExit();
+}
+
+static VReg CompileFunctionOrProgram(PandaGen *pg)
+{
+    FunctionRegScope lrs(pg);
+    const auto *topScope = pg->TopScope();
+
+    if (pg->FunctionHasFinalizer()) {
+        ASSERT(topScope->IsFunctionScope());
+
+        TryContext tryCtx(pg);
+        pg->FunctionInit(tryCtx.GetCatchTable());
+
+        CompileFunction(pg);
+    } else {
+        pg->FunctionInit(nullptr);
+
+        if (topScope->IsFunctionScope()) {
+            CompileFunction(pg);
+        } else {
+            ASSERT(topScope->IsGlobalScope() || topScope->IsModuleScope());
+            CompileSourceBlock(pg, pg->RootNode()->AsBlockStatement());
+        }
+    }
+
+    return pg->GetEnvScope()->LexEnv();
+}
+
+void Function::Compile(PandaGen *pg)
+{
+    VReg lexEnv = CompileFunctionOrProgram(pg);
+    pg->CopyFunctionArguments(pg->RootNode());
+    pg->InitializeLexEnv(pg->RootNode(), lexEnv);
+    pg->SortCatchTables();
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/function.h b/es2panda/compiler/core/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..4be6f755aacd317538303d5daeaf062a0896d898
--- /dev/null
+++ b/es2panda/compiler/core/function.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_FUNCTION_H
+#define ES2PANDA_COMPILER_CORE_FUNCTION_H
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class Function {
+public:
+    Function() = delete;
+
+    static void Compile(PandaGen *pg);
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/inlineCache.cpp b/es2panda/compiler/core/inlineCache.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0570e0f8977ce5746355358998eecf2a0cb858d5
--- /dev/null
+++ b/es2panda/compiler/core/inlineCache.cpp
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "inlineCache.h"
+
+#include <limits>
+
+namespace panda::es2panda::compiler {
+
+size_t InlineCache::Size() const
+{
+    return size_;
+}
+
+uint32_t InlineCache::Offset(uint32_t slotSize)
+{
+    uint32_t offset = size_ + slotSize;
+
+    constexpr uint32_t LIMIT = std::numeric_limits<uint16_t>::max();
+    if (offset > LIMIT) {
+        return LIMIT;
+    }
+
+    size_ = offset;
+    return offset;
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/inlineCache.h b/es2panda/compiler/core/inlineCache.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b8ee40827cd9e1be980527a5a842e34dc61a7e9
--- /dev/null
+++ b/es2panda/compiler/core/inlineCache.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_IR_INLINE_CACHE_H
+#define ES2PANDA_COMPILER_IR_INLINE_CACHE_H
+
+#include <macros.h>
+
+namespace panda::es2panda::compiler {
+
+class InlineCache {
+public:
+    explicit InlineCache() = default;
+
+    size_t Size() const;
+    uint32_t Offset(uint32_t slotSize);
+
+private:
+    size_t size_ {};
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/labelPair.h b/es2panda/compiler/core/labelPair.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec85351877c1ec7ad878b108e7e0c39baa5de882
--- /dev/null
+++ b/es2panda/compiler/core/labelPair.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_LABEL_PAIR_H
+#define ES2PANDA_COMPILER_CORE_LABEL_PAIR_H
+
+#include <macros.h>
+#include <ir/irnode.h>
+
+namespace panda::es2panda::compiler {
+class LabelPair {
+public:
+    LabelPair(Label *begin, Label *end) : begin_(begin), end_(end) {}
+
+    Label *Begin() const
+    {
+        return begin_;
+    }
+
+    Label *End() const
+    {
+        return end_;
+    }
+
+protected:
+    Label *begin_ {};
+    Label *end_ {};
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/labelTarget.cpp b/es2panda/compiler/core/labelTarget.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3fc9530fa07e3b66cd8c6e982274efeee2cfc3b1
--- /dev/null
+++ b/es2panda/compiler/core/labelTarget.cpp
@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "labelTarget.h"
+
+#include <compiler/core/pandagen.h>
+
+namespace panda::es2panda::compiler {
+
+LabelTarget::LabelTarget(PandaGen *pg)
+    : LabelPair(pg->AllocLabel(), pg->AllocLabel()), breakLabel_(BREAK_LABEL), continueLabel_(CONTINUE_LABEL)
+{
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/labelTarget.h b/es2panda/compiler/core/labelTarget.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c9ee9792b458ad55d9721d3b82c47d7786d2e14
--- /dev/null
+++ b/es2panda/compiler/core/labelTarget.h
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_LABEL_TARGET_H
+#define ES2PANDA_COMPILER_CORE_LABEL_TARGET_H
+
+#include <ir/irnode.h>
+#include <compiler/core/labelPair.h>
+
+#include <unordered_map>
+
+namespace panda::es2panda::ir {
+class AstNode;
+class Identifier;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class LabelTarget;
+class PandaGen;
+
+enum class ControlFlowChange {
+    CONTINUE,
+    BREAK,
+};
+
+class LabelTarget : public LabelPair {
+public:
+    explicit LabelTarget(PandaGen *pg);
+    explicit LabelTarget(const util::StringView &label) : LabelTarget(nullptr, label) {}
+    explicit LabelTarget(Label *target, const util::StringView &label)
+        : LabelPair(target, nullptr), breakLabel_(label), continueLabel_(label)
+    {
+    }
+    LabelTarget() : LabelPair(nullptr, nullptr) {};
+
+    ~LabelTarget() = default;
+    DEFAULT_COPY_SEMANTIC(LabelTarget);
+    DEFAULT_MOVE_SEMANTIC(LabelTarget);
+
+    const util::StringView &BreakLabel() const
+    {
+        return breakLabel_;
+    }
+
+    Label *BreakTarget() const
+    {
+        return begin_;
+    }
+
+    void SetBreakTarget(Label *label)
+    {
+        begin_ = label;
+    }
+
+    const util::StringView &ContinueLabel() const
+    {
+        return continueLabel_;
+    }
+
+    Label *ContinueTarget() const
+    {
+        return end_;
+    }
+
+    static constexpr std::string_view BREAK_LABEL = "#b";
+    static constexpr std::string_view CONTINUE_LABEL = "#c";
+
+private:
+    util::StringView breakLabel_ {};
+    util::StringView continueLabel_ {};
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/moduleContext.cpp b/es2panda/compiler/core/moduleContext.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..272a319c361a78ee4436ee60cf84cc30152e5f8f
--- /dev/null
+++ b/es2panda/compiler/core/moduleContext.cpp
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "moduleContext.h"
+
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <compiler/base/lreference.h>
+#include <compiler/core/pandagen.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/module/exportAllDeclaration.h>
+#include <ir/module/exportNamedDeclaration.h>
+#include <ir/module/importDeclaration.h>
+
+namespace panda::es2panda::compiler {
+void CompileImports(PandaGen *pg, binder::ModuleScope *scope)
+{
+    for (const auto &[importDecl, decls] : scope->Imports()) {
+        pg->ImportModule(importDecl, importDecl->Source()->Str());
+
+        VReg moduleReg = pg->AllocReg();
+        pg->StoreAccumulator(importDecl, moduleReg);
+
+        for (const auto *decl : decls) {
+            binder::Variable *v = scope->FindLocal(decl->LocalName());
+
+            if (!v->IsModuleVariable()) {
+                ASSERT(decl->ImportName() == "*");
+
+                binder::ScopeFindResult result(decl->LocalName(), scope, 0, v);
+                pg->StoreAccToLexEnv(decl->Node(), result, true);
+            } else {
+                v->AsModuleVariable()->ModuleReg() = moduleReg;
+            }
+        }
+    }
+}
+
+void CompileExports(PandaGen *pg, const binder::ModuleScope *scope)
+{
+    for (const auto &[exportDecl, decls] : scope->Exports()) {
+        if (exportDecl->IsExportAllDeclaration()) {
+            pg->ImportModule(exportDecl, exportDecl->AsExportAllDeclaration()->Source()->Str());
+        } else if (exportDecl->IsExportNamedDeclaration() && exportDecl->AsExportNamedDeclaration()->Source()) {
+            pg->ImportModule(exportDecl, exportDecl->AsExportNamedDeclaration()->Source()->Str());
+        } else {
+            continue;
+        }
+
+        VReg moduleReg = pg->AllocReg();
+        pg->StoreAccumulator(exportDecl, moduleReg);
+
+        if (exportDecl->IsExportAllDeclaration()) {
+            pg->StoreModuleVar(exportDecl, decls.front()->ExportName());
+            continue;
+        }
+
+        pg->CopyModule(exportDecl, moduleReg);
+
+        for (const auto *decl : decls) {
+            pg->LoadObjByName(decl->Node(), moduleReg, decl->LocalName());
+            pg->StoreModuleVar(decl->Node(), decl->ExportName());
+        }
+    }
+}
+
+void ModuleContext::Compile(PandaGen *pg, binder::ModuleScope *scope)
+{
+    CompileImports(pg, scope);
+    CompileExports(pg, scope);
+}
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/moduleContext.h b/es2panda/compiler/core/moduleContext.h
new file mode 100644
index 0000000000000000000000000000000000000000..da15b229feb4aa0fcc51b2146d6cc00bcb488010
--- /dev/null
+++ b/es2panda/compiler/core/moduleContext.h
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_MODULE_CONTEXT_H
+#define ES2PANDA_COMPILER_CORE_MODULE_CONTEXT_H
+
+#include <util/ustring.h>
+
+#include <vector>
+
+namespace panda::es2panda::binder {
+class Variable;
+class ModuleScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+
+class ModuleContext {
+public:
+    ModuleContext() = delete;
+
+    static void Compile(PandaGen *pg, binder::ModuleScope *scope);
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/pandagen.cpp b/es2panda/compiler/core/pandagen.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d58fa71c45b4622695a76884a4c7035854e2eac
--- /dev/null
+++ b/es2panda/compiler/core/pandagen.cpp
@@ -0,0 +1,1526 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "pandagen.h"
+
+#include <binder/binder.h>
+#include <util/helpers.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <compiler/base/catchTable.h>
+#include <compiler/base/lexenv.h>
+#include <compiler/base/literals.h>
+#include <compiler/core/compilerContext.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/core/regAllocator.h>
+#include <compiler/function/asyncFunctionBuilder.h>
+#include <compiler/function/asyncGeneratorFunctionBuilder.h>
+#include <compiler/function/functionBuilder.h>
+#include <compiler/function/generatorFunctionBuilder.h>
+#include <es2panda.h>
+#include <gen/isa.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/spreadElement.h>
+#include <ir/statement.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+
+namespace panda::es2panda::compiler {
+
+// PandaGen
+
+Label *PandaGen::AllocLabel()
+{
+    std::string id = std::string {Label::PREFIX} + std::to_string(labelId_++);
+    return sa_.AllocLabel(std::move(id));
+}
+
+bool PandaGen::IsDebug() const
+{
+    return context_->IsDebug();
+}
+
+uint32_t PandaGen::ParamCount() const
+{
+    if (rootNode_->IsProgram()) {
+        return 0;
+    }
+
+    return rootNode_->AsScriptFunction()->Params().size();
+}
+
+uint32_t PandaGen::FormalParametersCount() const
+{
+    if (rootNode_->IsProgram()) {
+        return 0;
+    }
+
+    ASSERT(rootNode_->IsScriptFunction());
+
+    return rootNode_->AsScriptFunction()->FormalParamsLength();
+}
+
+uint32_t PandaGen::InternalParamCount() const
+{
+    static const uint32_t HIDDEN_PARAMS = 3;
+    return ParamCount() + HIDDEN_PARAMS;
+}
+
+const util::StringView &PandaGen::InternalName() const
+{
+    return topScope_->InternalName();
+}
+
+const util::StringView &PandaGen::FunctionName() const
+{
+    return topScope_->Name();
+}
+
+binder::Binder *PandaGen::Binder() const
+{
+    return context_->Binder();
+}
+
+void PandaGen::FunctionInit(CatchTable *catchTable)
+{
+    if (rootNode_->IsProgram()) {
+        builder_ = allocator_->New<FunctionBuilder>(this, catchTable);
+        return;
+    }
+
+    const ir::ScriptFunction *func = rootNode_->AsScriptFunction();
+
+    if (func->IsAsync()) {
+        if (func->IsGenerator()) {
+            builder_ = allocator_->New<AsyncGeneratorFunctionBuilder>(this, catchTable);
+            return;
+        }
+
+        builder_ = allocator_->New<AsyncFunctionBuilder>(this, catchTable);
+        return;
+    }
+
+    if (func->IsGenerator()) {
+        builder_ = allocator_->New<GeneratorFunctionBuilder>(this, catchTable);
+        return;
+    }
+
+    builder_ = allocator_->New<FunctionBuilder>(this, catchTable);
+}
+
+bool PandaGen::FunctionHasFinalizer() const
+{
+    if (rootNode_->IsProgram()) {
+        return false;
+    }
+
+    const ir::ScriptFunction *func = rootNode_->AsScriptFunction();
+
+    return func->IsAsync() || func->IsGenerator();
+}
+
+void PandaGen::FunctionEnter()
+{
+    builder_->Prepare(rootNode_->AsScriptFunction());
+}
+
+void PandaGen::FunctionExit()
+{
+    builder_->CleanUp(rootNode_->AsScriptFunction());
+}
+
+void PandaGen::InitializeLexEnv(const ir::AstNode *node, VReg lexEnv)
+{
+    FrontAllocator fa(this);
+
+    if (topScope_->NeedLexEnv()) {
+        NewLexEnv(node, topScope_->LexicalSlots());
+    } else {
+        LdLexEnv(node);
+    }
+
+    StoreAccumulator(node, lexEnv);
+}
+
+void PandaGen::CopyFunctionArguments(const ir::AstNode *node)
+{
+    FrontAllocator fa(this);
+    VReg targetReg = totalRegs_;
+
+    for (const auto *param : topScope_->ParamScope()->Params()) {
+        if (param->LexicalBound()) {
+            LoadAccumulator(node, targetReg++);
+            StoreLexicalVar(node, 0, param->LexIdx());
+        } else {
+            ra_.Emit<MovDyn>(node, param->Vreg(), targetReg++);
+        }
+    }
+}
+
+LiteralBuffer *PandaGen::NewLiteralBuffer()
+{
+    return allocator_->New<LiteralBuffer>(allocator_);
+}
+
+int32_t PandaGen::AddLiteralBuffer(LiteralBuffer *buf)
+{
+    buffStorage_.push_back(buf);
+    buf->SetIndex(context_->NewLiteralIndex());
+    return buf->Index();
+}
+
+void PandaGen::GetFunctionObject(const ir::AstNode *node)
+{
+    LoadAccFromLexEnv(node, scope_->Find(binder::Binder::MANDATORY_PARAM_FUNC));
+}
+
+void PandaGen::GetNewTarget(const ir::AstNode *node)
+{
+    LoadAccFromLexEnv(node, scope_->Find(binder::Binder::MANDATORY_PARAM_NEW_TARGET));
+}
+
+void PandaGen::GetThis(const ir::AstNode *node)
+{
+    LoadAccFromLexEnv(node, scope_->Find(binder::Binder::MANDATORY_PARAM_THIS));
+}
+
+void PandaGen::SetThis(const ir::AstNode *node)
+{
+    StoreAccToLexEnv(node, scope_->Find(binder::Binder::MANDATORY_PARAM_THIS), true);
+}
+
+void PandaGen::LoadVar(const ir::Identifier *node, const binder::ScopeFindResult &result)
+{
+    auto *var = result.variable;
+
+    if (!var) {
+        TryLoadGlobalByName(node, result.name);
+        return;
+    }
+
+    if (var->IsGlobalVariable()) {
+        LoadGlobalVar(node, var->Name());
+        return;
+    }
+
+    if (var->IsModuleVariable()) {
+        LoadModuleVariable(node, var->AsModuleVariable()->ModuleReg(), var->AsModuleVariable()->ExoticName());
+        return;
+    }
+
+    ASSERT(var->IsLocalVariable());
+    LoadAccFromLexEnv(node, result);
+}
+
+void PandaGen::StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDeclaration)
+{
+    binder::Variable *var = result.variable;
+
+    if (!var) {
+        TryStoreGlobalByName(node, result.name);
+        return;
+    }
+
+    if (var->IsGlobalVariable()) {
+        StoreGlobalVar(node, var->Name());
+        return;
+    }
+
+    if (var->IsModuleVariable()) {
+        ThrowConstAssignment(node, var->Name());
+        return;
+    }
+
+    ASSERT(var->IsLocalVariable());
+    StoreAccToLexEnv(node, result, isDeclaration);
+}
+
+void PandaGen::StoreAccumulator(const ir::AstNode *node, VReg vreg)
+{
+    ra_.Emit<StaDyn>(node, vreg);
+}
+
+void PandaGen::LoadAccFromArgs(const ir::AstNode *node)
+{
+    const auto *varScope = scope_->AsVariableScope();
+
+    if (!varScope->HasFlag(binder::VariableScopeFlags::USE_ARGS)) {
+        return;
+    }
+
+    binder::ScopeFindResult res = scope_->Find(binder::Binder::FUNCTION_ARGUMENTS);
+    ASSERT(res.scope);
+
+    GetUnmappedArgs(node);
+    StoreAccToLexEnv(node, res, true);
+}
+
+void PandaGen::LoadObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
+{
+    if (std::holds_alternative<VReg>(prop)) {
+        LoadObjByValue(node, obj, std::get<VReg>(prop));
+        return;
+    }
+
+    if (std::holds_alternative<int64_t>(prop)) {
+        LoadObjByIndex(node, obj, std::get<int64_t>(prop));
+        return;
+    }
+
+    ASSERT(std::holds_alternative<util::StringView>(prop));
+    LoadObjByName(node, obj, std::get<util::StringView>(prop));
+}
+
+void PandaGen::StoreObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
+{
+    if (std::holds_alternative<VReg>(prop)) {
+        StoreObjByValue(node, obj, std::get<VReg>(prop));
+        return;
+    }
+
+    if (std::holds_alternative<int64_t>(prop)) {
+        StoreObjByIndex(node, obj, std::get<int64_t>(prop));
+        return;
+    }
+
+    ASSERT(std::holds_alternative<util::StringView>(prop));
+    StoreObjByName(node, obj, std::get<util::StringView>(prop));
+}
+
+void PandaGen::StoreOwnProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
+{
+    if (std::holds_alternative<VReg>(prop)) {
+        StOwnByValue(node, obj, std::get<VReg>(prop));
+        return;
+    }
+
+    if (std::holds_alternative<int64_t>(prop)) {
+        StOwnByIndex(node, obj, std::get<int64_t>(prop));
+        return;
+    }
+
+    ASSERT(std::holds_alternative<util::StringView>(prop));
+    StOwnByName(node, obj, std::get<util::StringView>(prop));
+}
+
+void PandaGen::TryLoadGlobalByName(const ir::AstNode *node, const util::StringView &name)
+{
+    sa_.Emit<EcmaTryldglobalbyname>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::TryStoreGlobalByName(const ir::AstNode *node, const util::StringView &name)
+{
+    sa_.Emit<EcmaTrystglobalbyname>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::LoadObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop)
+{
+    ra_.Emit<EcmaLdobjbyname>(node, prop, obj);
+    strings_.insert(prop);
+}
+
+void PandaGen::StoreObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop)
+{
+    ra_.Emit<EcmaStobjbyname>(node, prop, obj);
+    strings_.insert(prop);
+}
+
+void PandaGen::LoadObjByIndex(const ir::AstNode *node, VReg obj, int64_t index)
+{
+    ra_.Emit<EcmaLdobjbyindex>(node, index, obj);
+}
+
+void PandaGen::LoadObjByValue(const ir::AstNode *node, VReg obj, VReg prop)
+{
+    ra_.Emit<EcmaLdobjbyvalue>(node, obj, prop);
+}
+
+void PandaGen::StoreObjByValue(const ir::AstNode *node, VReg obj, VReg prop)
+{
+    ra_.Emit<EcmaStobjbyvalue>(node, obj, prop);
+}
+
+void PandaGen::StoreObjByIndex(const ir::AstNode *node, VReg obj, int64_t index)
+{
+    ra_.Emit<EcmaStobjbyindex>(node, index, obj);
+}
+
+void PandaGen::StOwnByName(const ir::AstNode *node, VReg obj, const util::StringView &prop)
+{
+    ra_.Emit<EcmaStownbyname>(node, prop, obj);
+    strings_.insert(prop);
+}
+
+void PandaGen::StOwnByValue(const ir::AstNode *node, VReg obj, VReg prop)
+{
+    ra_.Emit<EcmaStownbyvalue>(node, obj, prop);
+}
+
+void PandaGen::StOwnByIndex(const ir::AstNode *node, VReg obj, int64_t index)
+{
+    ra_.Emit<EcmaStownbyindex>(node, index, obj);
+}
+
+void PandaGen::DeleteObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
+{
+    VReg property {};
+
+    if (std::holds_alternative<VReg>(prop)) {
+        property = std::get<VReg>(prop);
+    } else if (std::holds_alternative<int64_t>(prop)) {
+        LoadAccumulatorInt(node, static_cast<size_t>(std::get<int64_t>(prop)));
+        property = AllocReg();
+        StoreAccumulator(node, property);
+    } else {
+        ASSERT(std::holds_alternative<util::StringView>(prop));
+        LoadAccumulatorString(node, std::get<util::StringView>(prop));
+        property = AllocReg();
+        StoreAccumulator(node, property);
+    }
+
+    ra_.Emit<EcmaDelobjprop>(node, obj, property);
+}
+
+void PandaGen::LoadAccumulator(const ir::AstNode *node, VReg reg)
+{
+    ra_.Emit<LdaDyn>(node, reg);
+}
+
+void PandaGen::LoadGlobalVar(const ir::AstNode *node, const util::StringView &name)
+{
+    sa_.Emit<EcmaLdglobalvar>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::StoreGlobalVar(const ir::AstNode *node, const util::StringView &name)
+{
+    sa_.Emit<EcmaStglobalvar>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::StoreGlobalLet(const ir::AstNode *node, const util::StringView &name)
+{
+    sa_.Emit<EcmaStgloballet>(node, name);
+    strings_.insert(name);
+}
+
+VReg PandaGen::LexEnv() const
+{
+    return envScope_->LexEnv();
+}
+
+void PandaGen::LoadAccFromLexEnv(const ir::AstNode *node, const binder::ScopeFindResult &result)
+{
+    VirtualLoadVar::Expand(this, node, result);
+}
+
+void PandaGen::StoreAccToLexEnv(const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDeclaration)
+{
+    VirtualStoreVar::Expand(this, node, result, isDeclaration);
+}
+
+void PandaGen::LoadAccumulatorString(const ir::AstNode *node, const util::StringView &str)
+{
+    sa_.Emit<LdaStr>(node, str);
+    strings_.insert(str);
+}
+
+void PandaGen::LoadAccumulatorFloat(const ir::AstNode *node, double num)
+{
+    sa_.Emit<FldaiDyn>(node, num);
+}
+
+void PandaGen::LoadAccumulatorInt(const ir::AstNode *node, int32_t num)
+{
+    sa_.Emit<LdaiDyn>(node, num);
+}
+
+void PandaGen::LoadAccumulatorInt(const ir::AstNode *node, size_t num)
+{
+    sa_.Emit<LdaiDyn>(node, static_cast<int64_t>(num));
+}
+
+void PandaGen::StoreConst(const ir::AstNode *node, VReg reg, Constant id)
+{
+    LoadConst(node, id);
+    StoreAccumulator(node, reg);
+}
+
+void PandaGen::LoadConst(const ir::AstNode *node, Constant id)
+{
+    switch (id) {
+        case Constant::JS_HOLE: {
+            sa_.Emit<EcmaLdhole>(node);
+            break;
+        }
+        case Constant::JS_NAN: {
+            sa_.Emit<EcmaLdnan>(node);
+            break;
+        }
+        case Constant::JS_INFINITY: {
+            sa_.Emit<EcmaLdinfinity>(node);
+            break;
+        }
+        case Constant::JS_GLOBAL: {
+            sa_.Emit<EcmaLdglobal>(node);
+            break;
+        }
+        case Constant::JS_UNDEFINED: {
+            sa_.Emit<EcmaLdundefined>(node);
+            break;
+        }
+        case Constant::JS_SYMBOL: {
+            sa_.Emit<EcmaLdsymbol>(node);
+            break;
+        }
+        case Constant::JS_NULL: {
+            sa_.Emit<EcmaLdnull>(node);
+            break;
+        }
+        case Constant::JS_TRUE: {
+            sa_.Emit<EcmaLdtrue>(node);
+            break;
+        }
+        case Constant::JS_FALSE: {
+            sa_.Emit<EcmaLdfalse>(node);
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+void PandaGen::MoveVreg(const ir::AstNode *node, VReg vd, VReg vs)
+{
+    ra_.Emit<MovDyn>(node, vd, vs);
+}
+
+void PandaGen::SetLabel([[maybe_unused]] const ir::AstNode *node, Label *label)
+{
+    sa_.AddLabel(label);
+}
+
+void PandaGen::Branch(const ir::AstNode *node, Label *label)
+{
+    sa_.Emit<Jmp>(node, label);
+}
+
+bool PandaGen::CheckControlFlowChange()
+{
+    const auto *iter = dynamicContext_;
+
+    while (iter) {
+        if (iter->HasFinalizer()) {
+            return true;
+        }
+
+        iter = iter->Prev();
+    }
+
+    return false;
+}
+
+Label *PandaGen::ControlFlowChangeBreak(const ir::Identifier *label)
+{
+    auto *iter = dynamicContext_;
+
+    util::StringView labelName = label ? label->Name() : LabelTarget::BREAK_LABEL;
+    Label *breakTarget = nullptr;
+
+    while (iter) {
+        iter->AbortContext(ControlFlowChange::BREAK, labelName);
+
+        const auto &labelTargetName = iter->Target().BreakLabel();
+
+        if (iter->Target().BreakTarget()) {
+            breakTarget = iter->Target().BreakTarget();
+        }
+
+        if (labelTargetName == labelName) {
+            break;
+        }
+
+        iter = iter->Prev();
+    }
+
+    return breakTarget;
+}
+
+Label *PandaGen::ControlFlowChangeContinue(const ir::Identifier *label)
+{
+    auto *iter = dynamicContext_;
+    util::StringView labelName = label ? label->Name() : LabelTarget::CONTINUE_LABEL;
+    Label *continueTarget = nullptr;
+
+    while (iter) {
+        iter->AbortContext(ControlFlowChange::CONTINUE, labelName);
+
+        const auto &labelTargetName = iter->Target().ContinueLabel();
+
+        if (iter->Target().ContinueTarget()) {
+            continueTarget = iter->Target().ContinueTarget();
+        }
+
+        if (labelTargetName == labelName) {
+            break;
+        }
+
+        iter = iter->Prev();
+    }
+
+    return continueTarget;
+}
+
+void PandaGen::Condition(const ir::AstNode *node, lexer::TokenType op, VReg lhs, Label *ifFalse)
+{
+    switch (op) {
+        case lexer::TokenType::PUNCTUATOR_EQUAL: {
+            ra_.Emit<EcmaEqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_NOT_EQUAL: {
+            ra_.Emit<EcmaNoteqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL: {
+            ra_.Emit<EcmaStricteqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL: {
+            ra_.Emit<EcmaStrictnoteqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN: {
+            ra_.Emit<EcmaLessdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL: {
+            ra_.Emit<EcmaLesseqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN: {
+            ra_.Emit<EcmaGreaterdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL: {
+            ra_.Emit<EcmaGreatereqdyn>(node, lhs);
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+
+    BranchIfFalse(node, ifFalse);
+}
+
+void PandaGen::Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand)
+{
+    switch (op) {
+        case lexer::TokenType::PUNCTUATOR_PLUS: {
+            ra_.Emit<EcmaTonumber>(node, operand);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_MINUS: {
+            ra_.Emit<EcmaNegdyn>(node, operand);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_TILDE: {
+            ra_.Emit<EcmaNotdyn>(node, operand);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK: {
+            sa_.Emit<EcmaNegate>(node);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_PLUS_PLUS: {
+            ra_.Emit<EcmaIncdyn>(node, operand);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_MINUS_MINUS: {
+            ra_.Emit<EcmaDecdyn>(node, operand);
+            break;
+        }
+        case lexer::TokenType::KEYW_VOID:
+        case lexer::TokenType::KEYW_DELETE: {
+            LoadConst(node, Constant::JS_UNDEFINED);
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+void PandaGen::Binary(const ir::AstNode *node, lexer::TokenType op, VReg lhs)
+{
+    switch (op) {
+        case lexer::TokenType::PUNCTUATOR_EQUAL: {
+            ra_.Emit<EcmaEqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_NOT_EQUAL: {
+            ra_.Emit<EcmaNoteqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL: {
+            ra_.Emit<EcmaStricteqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL: {
+            ra_.Emit<EcmaStrictnoteqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN: {
+            ra_.Emit<EcmaLessdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL: {
+            ra_.Emit<EcmaLesseqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN: {
+            ra_.Emit<EcmaGreaterdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL: {
+            ra_.Emit<EcmaGreatereqdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_PLUS:
+        case lexer::TokenType::PUNCTUATOR_PLUS_EQUAL: {
+            ra_.Emit<EcmaAdd2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_MINUS:
+        case lexer::TokenType::PUNCTUATOR_MINUS_EQUAL: {
+            ra_.Emit<EcmaSub2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY:
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY_EQUAL: {
+            ra_.Emit<EcmaMul2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_DIVIDE:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL: {
+            ra_.Emit<EcmaDiv2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_MOD:
+        case lexer::TokenType::PUNCTUATOR_MOD_EQUAL: {
+            ra_.Emit<EcmaMod2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION: {
+            ra_.Emit<EcmaExpdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL: {
+            ra_.Emit<EcmaShl2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL: {
+            ra_.Emit<EcmaShr2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL: {
+            ra_.Emit<EcmaAshr2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL: {
+            ra_.Emit<EcmaAnd2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL: {
+            ra_.Emit<EcmaOr2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL: {
+            ra_.Emit<EcmaXor2dyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::KEYW_IN: {
+            ra_.Emit<EcmaIsindyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::KEYW_INSTANCEOF: {
+            ra_.Emit<EcmaInstanceofdyn>(node, lhs);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING:
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_NULLISH_EQUAL: {
+            Unimplemented();
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+void PandaGen::BranchIfUndefined(const ir::AstNode *node, Label *target)
+{
+    sa_.Emit<EcmaIsundefined>(node);
+    BranchIfTrue(node, target);
+}
+
+void PandaGen::BranchIfNotUndefined(const ir::AstNode *node, Label *target)
+{
+    sa_.Emit<EcmaIsundefined>(node);
+    BranchIfFalse(node, target);
+}
+
+void PandaGen::BranchIfTrue(const ir::AstNode *node, Label *target)
+{
+    sa_.Emit<EcmaJtrue>(node, target);
+}
+
+void PandaGen::BranchIfNotTrue(const ir::AstNode *node, Label *target)
+{
+    sa_.Emit<EcmaIstrue>(node);
+    BranchIfFalse(node, target);
+}
+
+void PandaGen::BranchIfFalse(const ir::AstNode *node, Label *target)
+{
+    sa_.Emit<EcmaJfalse>(node, target);
+}
+
+void PandaGen::BranchIfCoercible(const ir::AstNode *node, Label *target)
+{
+    sa_.Emit<EcmaIscoercible>(node);
+    BranchIfTrue(node, target);
+}
+
+void PandaGen::EmitThrow(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaThrowdyn>(node);
+}
+
+void PandaGen::EmitRethrow(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaRethrowdyn>(node);
+}
+
+void PandaGen::EmitReturn(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaReturnDyn>(node);
+}
+
+void PandaGen::EmitReturnUndefined(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaReturnundefined>(node);
+}
+
+void PandaGen::ImplicitReturn(const ir::AstNode *node)
+{
+    builder_->ImplicitReturn(node);
+}
+
+void PandaGen::DirectReturn(const ir::AstNode *node)
+{
+    builder_->DirectReturn(node);
+}
+
+void PandaGen::ValidateClassDirectReturn(const ir::AstNode *node)
+{
+    const ir::ScriptFunction *func = util::Helpers::GetContainingFunction(node);
+
+    if (!func || !func->IsConstructor()) {
+        return;
+    }
+
+    RegScope rs(this);
+    VReg value = AllocReg();
+    StoreAccumulator(node, value);
+
+    auto *notUndefined = AllocLabel();
+    auto *condEnd = AllocLabel();
+
+    BranchIfNotUndefined(node, notUndefined);
+    GetThis(func);
+    ThrowIfSuperNotCorrectCall(func, 0);
+    Branch(node, condEnd);
+
+    SetLabel(node, notUndefined);
+    LoadAccumulator(node, value);
+
+    SetLabel(node, condEnd);
+}
+
+void PandaGen::EmitAwait(const ir::AstNode *node)
+{
+    builder_->Await(node);
+}
+
+void PandaGen::CallThis(const ir::AstNode *node, VReg startReg, size_t argCount)
+{
+    rra_.Emit<EcmaCallithisrangedyn>(node, startReg, argCount + 2, static_cast<int64_t>(argCount), startReg);
+}
+
+void PandaGen::Call(const ir::AstNode *node, VReg startReg, size_t argCount)
+{
+    VReg callee = startReg;
+
+    switch (argCount) {
+        case 0: { // 0 args
+            ra_.Emit<EcmaCall0dyn>(node, callee);
+            break;
+        }
+        case 1: { // 1 arg
+            VReg arg0 = callee + 1;
+            ra_.Emit<EcmaCall1dyn>(node, callee, arg0);
+            break;
+        }
+        case 2: { // 2 args
+            VReg arg0 = callee + 1;
+            VReg arg1 = arg0 + 1;
+            ra_.Emit<EcmaCall2dyn>(node, callee, arg0, arg1);
+            break;
+        }
+        case 3: { // 3 args
+            VReg arg0 = callee + 1;
+            VReg arg1 = arg0 + 1;
+            VReg arg2 = arg1 + 1;
+            ra_.Emit<EcmaCall3dyn>(node, callee, arg0, arg1, arg2);
+            break;
+        }
+        default: {
+            rra_.Emit<EcmaCallirangedyn>(node, startReg, argCount + 1, static_cast<int64_t>(argCount), startReg);
+            break;
+        }
+    }
+}
+
+void PandaGen::SuperCall(const ir::AstNode *node, VReg startReg, size_t argCount)
+{
+    rra_.Emit<EcmaSupercall>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
+}
+
+void PandaGen::SuperCallSpread(const ir::AstNode *node, VReg vs)
+{
+    ra_.Emit<EcmaSupercallspread>(node, vs);
+}
+
+void PandaGen::NewObject(const ir::AstNode *node, VReg startReg, size_t argCount)
+{
+    rra_.Emit<EcmaNewobjdynrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
+}
+
+void PandaGen::LoadHomeObject(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaLdhomeobject>(node);
+}
+
+void PandaGen::DefineFunction(const ir::AstNode *node, const ir::ScriptFunction *realNode, const util::StringView &name)
+{
+    if (realNode->IsAsync()) {
+        if (realNode->IsGenerator()) {
+            ra_.Emit<EcmaDefineasyncgeneratorfunc>(node, name, LexEnv());
+        } else {
+            ra_.Emit<EcmaDefineasyncfunc>(node, name, LexEnv());
+        }
+    } else if (realNode->IsGenerator()) {
+        ra_.Emit<EcmaDefinegeneratorfunc>(node, name, LexEnv());
+    } else if (realNode->IsArrow()) {
+        LoadHomeObject(node);
+        ra_.Emit<EcmaDefinencfuncdyn>(node, name, LexEnv());
+    } else if (realNode->IsMethod()) {
+        ra_.Emit<EcmaDefinemethod>(node, name, LexEnv());
+    } else {
+        ra_.Emit<EcmaDefinefuncdyn>(node, name, LexEnv());
+    }
+
+    strings_.insert(name);
+}
+
+void PandaGen::TypeOf(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaTypeofdyn>(node);
+}
+
+void PandaGen::CallSpread(const ir::AstNode *node, VReg func, VReg thisReg, VReg args)
+{
+    ra_.Emit<EcmaCallspreaddyn>(node, func, thisReg, args);
+}
+
+void PandaGen::NewObjSpread(const ir::AstNode *node, VReg obj, VReg target)
+{
+    ra_.Emit<EcmaNewobjspreaddyn>(node, obj, target);
+}
+
+void PandaGen::GetUnmappedArgs(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaGetunmappedargs>(node);
+}
+
+void PandaGen::Negate(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaNegate>(node);
+}
+
+void PandaGen::ToBoolean(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaToboolean>(node);
+}
+
+void PandaGen::ToNumber(const ir::AstNode *node, VReg arg)
+{
+    ra_.Emit<EcmaTonumber>(node, arg);
+}
+
+void PandaGen::GetMethod(const ir::AstNode *node, VReg obj, const util::StringView &name)
+{
+    ra_.Emit<EcmaGetmethod>(node, name, obj);
+    strings_.insert(name);
+}
+
+void PandaGen::CreateGeneratorObj(const ir::AstNode *node, VReg funcObj)
+{
+    ra_.Emit<EcmaCreategeneratorobj>(node, funcObj);
+}
+
+void PandaGen::CreateAsyncGeneratorObj(const ir::AstNode *node, VReg funcObj)
+{
+    ra_.Emit<EcmaCreateasyncgeneratorobj>(node, funcObj);
+}
+
+void PandaGen::CreateIterResultObject(const ir::AstNode *node, bool done)
+{
+    ra_.Emit<EcmaCreateiterresultobj>(node, static_cast<int32_t>(done));
+}
+
+void PandaGen::SuspendGenerator(const ir::AstNode *node, VReg genObj)
+{
+    ra_.Emit<EcmaSuspendgenerator>(node, genObj);
+}
+
+void PandaGen::SuspendAsyncGenerator(const ir::AstNode *node, VReg asyncGenObj)
+{
+    ra_.Emit<EcmaSuspendasyncgenerator>(node, asyncGenObj);
+}
+
+void PandaGen::GeneratorYield(const ir::AstNode *node, VReg genObj)
+{
+    ra_.Emit<EcmaSetgeneratorstate>(node, genObj, static_cast<int32_t>(GeneratorState::SUSPENDED_YIELD));
+}
+
+void PandaGen::GeneratorComplete(const ir::AstNode *node, VReg genObj)
+{
+    ra_.Emit<EcmaSetgeneratorstate>(node, genObj, static_cast<int32_t>(GeneratorState::COMPLETED));
+}
+
+void PandaGen::ResumeGenerator(const ir::AstNode *node, VReg genObj)
+{
+    ra_.Emit<EcmaResumegenerator>(node, genObj);
+}
+
+void PandaGen::GetResumeMode(const ir::AstNode *node, VReg genObj)
+{
+    ra_.Emit<EcmaGetresumemode>(node, genObj);
+}
+
+void PandaGen::AsyncFunctionEnter(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaAsyncfunctionenter>(node);
+}
+
+void PandaGen::AsyncFunctionAwait(const ir::AstNode *node, VReg asyncFuncObj)
+{
+    ra_.Emit<EcmaAsyncfunctionawait>(node, asyncFuncObj);
+}
+
+void PandaGen::AsyncFunctionResolve(const ir::AstNode *node, VReg asyncFuncObj)
+{
+    ra_.Emit<EcmaAsyncfunctionresolve>(node, asyncFuncObj);
+}
+
+void PandaGen::AsyncFunctionReject(const ir::AstNode *node, VReg asyncFuncObj)
+{
+    ra_.Emit<EcmaAsyncfunctionreject>(node, asyncFuncObj);
+}
+
+void PandaGen::AsyncGeneratorResolve(const ir::AstNode *node, VReg asyncGenObj)
+{
+    ra_.Emit<EcmaAsyncgeneratorresolve>(node, asyncGenObj);
+}
+
+void PandaGen::AsyncGeneratorReject(const ir::AstNode *node, VReg asyncGenObj)
+{
+    ra_.Emit<EcmaAsyncgeneratorreject>(node, asyncGenObj);
+}
+
+void PandaGen::GetTemplateObject(const ir::AstNode *node, VReg value)
+{
+    ra_.Emit<EcmaGettemplateobject>(node, value);
+}
+
+void PandaGen::CopyRestArgs(const ir::AstNode *node, uint32_t index)
+{
+    sa_.Emit<EcmaCopyrestargs>(node, index);
+}
+
+void PandaGen::GetPropIterator(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaGetpropiterator>(node);
+}
+
+void PandaGen::GetNextPropName(const ir::AstNode *node, VReg iter)
+{
+    ra_.Emit<EcmaGetnextpropname>(node, iter);
+}
+
+void PandaGen::CreateEmptyObject(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaCreateemptyobject>(node);
+}
+
+void PandaGen::CreateObjectWithBuffer(const ir::AstNode *node, uint32_t idx)
+{
+    ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
+    sa_.Emit<EcmaCreateobjectwithbuffer>(node, idx);
+}
+
+void PandaGen::CreateObjectHavingMethod(const ir::AstNode *node, uint32_t idx)
+{
+    ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
+    LoadAccumulator(node, LexEnv());
+    sa_.Emit<EcmaCreateobjecthavingmethod>(node, idx);
+}
+
+void PandaGen::SetObjectWithProto(const ir::AstNode *node, VReg proto, VReg obj)
+{
+    ra_.Emit<EcmaSetobjectwithproto>(node, proto, obj);
+}
+
+void PandaGen::CopyDataProperties(const ir::AstNode *node, VReg dst, VReg src)
+{
+    ra_.Emit<EcmaCopydataproperties>(node, dst, src);
+}
+
+void PandaGen::DefineGetterSetterByValue(const ir::AstNode *node, VReg obj, VReg name, VReg getter, VReg setter,
+                                         bool setName)
+{
+    LoadConst(node, setName ? Constant::JS_TRUE : Constant::JS_FALSE);
+    ra_.Emit<EcmaDefinegettersetterbyvalue>(node, obj, name, getter, setter);
+}
+
+void PandaGen::CreateEmptyArray(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaCreateemptyarray>(node);
+}
+
+void PandaGen::CreateArrayWithBuffer(const ir::AstNode *node, uint32_t idx)
+{
+    ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
+    sa_.Emit<EcmaCreatearraywithbuffer>(node, idx);
+}
+
+void PandaGen::CreateArray(const ir::AstNode *node, const ArenaVector<ir::Expression *> &elements, VReg obj)
+{
+    if (elements.empty()) {
+        CreateEmptyArray(node);
+        StoreAccumulator(node, obj);
+        return;
+    }
+
+    auto *buf = NewLiteralBuffer();
+
+    size_t i = 0;
+    // This loop handles constant literal data by collecting it into a literal buffer
+    // until a non-constant element is encountered.
+    while (i < elements.size() && util::Helpers::IsConstantExpr(elements[i])) {
+        buf->Add(elements[i]->AsLiteral());
+        i++;
+    }
+
+    if (buf->IsEmpty()) {
+        CreateEmptyArray(node);
+    } else {
+        uint32_t bufIdx = AddLiteralBuffer(buf);
+        CreateArrayWithBuffer(node, bufIdx);
+    }
+
+    StoreAccumulator(node, obj);
+
+    if (i == elements.size()) {
+        return;
+    }
+
+    bool hasSpread = false;
+
+    // This loop handles array elements until a spread element is encountered
+    for (; i < elements.size(); i++) {
+        const ir::Expression *elem = elements[i];
+
+        if (elem->IsOmittedExpression()) {
+            continue;
+        }
+
+        if (elem->IsSpreadElement()) {
+            // The next loop will handle arrays that have a spread element
+            hasSpread = true;
+            break;
+        }
+
+        elem->Compile(this);
+        StOwnByIndex(elem, obj, i);
+    }
+
+    RegScope rs(this);
+    VReg idxReg {};
+
+    if (hasSpread) {
+        idxReg = AllocReg();
+        LoadAccumulatorInt(node, i);
+        StoreAccumulator(node, idxReg);
+    }
+
+    // This loop handles arrays that contain spread elements
+    for (; i < elements.size(); i++) {
+        const ir::Expression *elem = elements[i];
+
+        if (elem->IsSpreadElement()) {
+            elem->AsSpreadElement()->Argument()->Compile(this);
+
+            StoreArraySpread(elem, obj, idxReg);
+
+            LoadObjByName(node, obj, "length");
+            StoreAccumulator(elem, idxReg);
+            continue;
+        }
+
+        if (!elem->IsOmittedExpression()) {
+            elem->Compile(this);
+            StOwnByValue(elem, obj, idxReg);
+        }
+
+        Unary(elem, lexer::TokenType::PUNCTUATOR_PLUS_PLUS, idxReg);
+        StoreAccumulator(elem, idxReg);
+    }
+
+    // If the last element is omitted, we also have to update the length property
+    if (elements.back()->IsOmittedExpression()) {
+        // if there was a spread value then acc already contains the length
+        if (!hasSpread) {
+            LoadAccumulatorInt(node, i);
+        }
+
+        StOwnByName(node, obj, "length");
+    }
+
+    LoadAccumulator(node, obj);
+}
+
+void PandaGen::StoreArraySpread(const ir::AstNode *node, VReg array, VReg index)
+{
+    ra_.Emit<EcmaStarrayspread>(node, array, index);
+}
+
+void PandaGen::ThrowIfNotObject(const ir::AstNode *node)
+{
+    ra_.Emit<EcmaThrowifnotobject>(node);
+}
+
+void PandaGen::ThrowThrowNotExist(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaThrowthrownotexists>(node);
+}
+
+void PandaGen::GetIterator(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaGetiterator>(node);
+}
+
+void PandaGen::GetAsyncIterator(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaGetasynciterator>(node);
+}
+
+void PandaGen::CreateObjectWithExcludedKeys(const ir::AstNode *node, VReg obj, VReg argStart, size_t argCount)
+{
+    ASSERT(argStart == obj + 1);
+    if (argCount == 0) {  // Do not emit undefined register
+        argStart = obj;
+    }
+
+    rra_.Emit<EcmaCreateobjectwithexcludedkeys>(node, argStart, argCount, static_cast<int64_t>(argCount), obj,
+                                                argStart);
+}
+
+void PandaGen::ThrowObjectNonCoercible(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaThrowpatternnoncoercible>(node);
+}
+
+void PandaGen::CloseIterator(const ir::AstNode *node, VReg iter)
+{
+    ra_.Emit<EcmaCloseiterator>(node, iter);
+}
+
+void PandaGen::ImportModule(const ir::AstNode *node, const util::StringView &name)
+{
+    sa_.Emit<EcmaImportmodule>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::DefineClassWithBuffer(const ir::AstNode *node, const util::StringView &ctorId, int32_t litIdx,
+                                     VReg lexenv, VReg base)
+{
+    ra_.Emit<EcmaDefineclasswithbuffer>(node, ctorId, litIdx, lexenv, base);
+    strings_.insert(ctorId);
+}
+
+void PandaGen::LoadModuleVariable(const ir::AstNode *node, VReg module, const util::StringView &name)
+{
+    ra_.Emit<EcmaLdmodvarbyname>(node, name, module);
+    strings_.insert(name);
+}
+
+void PandaGen::StoreModuleVar(const ir::AstNode *node, const util::StringView &name)
+{
+    sa_.Emit<EcmaStmodulevar>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::CopyModule(const ir::AstNode *node, VReg module)
+{
+    ra_.Emit<EcmaCopymodule>(node, module);
+}
+
+void PandaGen::StSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key)
+{
+    ra_.Emit<EcmaStsuperbyname>(node, key, obj);
+    strings_.insert(key);
+}
+
+void PandaGen::LdSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key)
+{
+    ra_.Emit<EcmaLdsuperbyname>(node, key, obj);
+    strings_.insert(key);
+}
+
+void PandaGen::StSuperByValue(const ir::AstNode *node, VReg obj, VReg prop)
+{
+    ra_.Emit<EcmaStsuperbyvalue>(node, obj, prop);
+}
+
+void PandaGen::LdSuperByValue(const ir::AstNode *node, VReg obj, VReg prop)
+{
+    ra_.Emit<EcmaLdsuperbyvalue>(node, obj, prop);
+}
+
+void PandaGen::StoreSuperProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
+{
+    if (std::holds_alternative<util::StringView>(prop)) {
+        StSuperByName(node, obj, std::get<util::StringView>(prop));
+        return;
+    }
+
+    if (std::holds_alternative<VReg>(prop)) {
+        StSuperByValue(node, obj, std::get<VReg>(prop));
+        return;
+    }
+
+    ASSERT(std::holds_alternative<int64_t>(prop));
+    RegScope rs(this);
+    VReg property = AllocReg();
+    VReg value = AllocReg();
+
+    StoreAccumulator(node, value);
+    LoadAccumulatorInt(node, static_cast<size_t>(std::get<int64_t>(prop)));
+    StoreAccumulator(node, property);
+    LoadAccumulator(node, value);
+    StSuperByValue(node, obj, property);
+}
+
+void PandaGen::LoadSuperProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
+{
+    if (std::holds_alternative<util::StringView>(prop)) {
+        LdSuperByName(node, obj, std::get<util::StringView>(prop));
+        return;
+    }
+
+    if (std::holds_alternative<VReg>(prop)) {
+        LdSuperByValue(node, obj, std::get<VReg>(prop));
+        return;
+    }
+
+    ASSERT(std::holds_alternative<int64_t>(prop));
+    RegScope rs(this);
+
+    LoadAccumulatorInt(node, static_cast<size_t>(std::get<int64_t>(prop)));
+    VReg property = AllocReg();
+    StoreAccumulator(node, property);
+    LdSuperByValue(node, obj, property);
+}
+
+void PandaGen::LoadLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot)
+{
+    sa_.Emit<EcmaLdlexvardyn>(node, level, slot);
+}
+
+void PandaGen::StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot)
+{
+    ra_.Emit<EcmaStlexvardyn>(node, level, slot);
+}
+
+void PandaGen::ThrowIfSuperNotCorrectCall(const ir::AstNode *node, int64_t num)
+{
+    sa_.Emit<EcmaThrowifsupernotcorrectcall>(node, num);
+}
+
+void PandaGen::ThrowUndefinedIfHole(const ir::AstNode *node, const util::StringView &name)
+{
+    ra_.Emit<EcmaThrowundefinedifhole>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::ThrowConstAssignment(const ir::AstNode *node, const util::StringView &name)
+{
+    ra_.Emit<EcmaThrowconstassignment>(node, name);
+    strings_.insert(name);
+}
+
+void PandaGen::PopLexEnv(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaPoplexenvdyn>(node);
+}
+
+void PandaGen::CopyLexEnv(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaCopylexenvdyn>(node);
+}
+
+void PandaGen::NewLexEnv(const ir::AstNode *node, uint32_t num)
+{
+    sa_.Emit<EcmaNewlexenvdyn>(node, num);
+}
+
+void PandaGen::LdLexEnv(const ir::AstNode *node)
+{
+    sa_.Emit<EcmaLdlexenvdyn>(node);
+}
+
+uint32_t PandaGen::TryDepth() const
+{
+    const auto *iter = dynamicContext_;
+    uint32_t depth = 0;
+
+    while (iter) {
+        if (iter->HasTryCatch()) {
+            depth++;
+        }
+
+        iter = iter->Prev();
+    }
+
+    return depth;
+}
+
+CatchTable *PandaGen::CreateCatchTable()
+{
+    auto *catchTable = allocator_->New<CatchTable>(this, TryDepth());
+    catchList_.push_back(catchTable);
+    return catchTable;
+}
+
+void PandaGen::SortCatchTables()
+{
+    std::sort(catchList_.begin(), catchList_.end(),
+              [](const CatchTable *a, const CatchTable *b) { return b->Depth() < a->Depth(); });
+}
+
+Operand PandaGen::ToNamedPropertyKey(const ir::Expression *prop, bool isComputed)
+{
+    VReg res {0};
+
+    if (!isComputed) {
+        if (prop->IsIdentifier()) {
+            return prop->AsIdentifier()->Name();
+        }
+    } else if (prop->IsStringLiteral()) {
+        const util::StringView &str = prop->AsStringLiteral()->Str();
+
+        /* TODO(dbatyai): remove this when runtime handles __proto__ as property name correctly */
+        if (str.Is("__proto__")) {
+            return res;
+        }
+
+        int64_t index = util::Helpers::GetIndex(str);
+        if (index != util::Helpers::INVALID_INDEX) {
+            return index;
+        }
+
+        return str;
+    } else if (prop->IsNumberLiteral()) {
+        auto num = prop->AsNumberLiteral()->Number<double>();
+        if (util::Helpers::IsIndex(num)) {
+            return static_cast<int64_t>(num);
+        }
+
+        return prop->AsNumberLiteral()->Str();
+    }
+
+    return res;
+}
+
+Operand PandaGen::ToPropertyKey(const ir::Expression *prop, bool isComputed)
+{
+    Operand op = ToNamedPropertyKey(prop, isComputed);
+    if (!std::holds_alternative<VReg>(op)) {
+        ASSERT(std::holds_alternative<util::StringView>(op) || std::holds_alternative<int64_t>(op));
+        return op;
+    }
+
+    VReg propReg = AllocReg();
+
+    prop->Compile(this);
+    StoreAccumulator(prop, propReg);
+
+    return propReg;
+}
+
+VReg PandaGen::LoadPropertyKey(const ir::Expression *prop, bool isComputed)
+{
+    Operand op = ToNamedPropertyKey(prop, isComputed);
+
+    if (std::holds_alternative<util::StringView>(op)) {
+        LoadAccumulatorString(prop, std::get<util::StringView>(op));
+    } else if (std::holds_alternative<int64_t>(op)) {
+        LoadAccumulatorInt(prop, static_cast<size_t>(std::get<int64_t>(op)));
+    } else {
+        prop->Compile(this);
+    }
+
+    VReg propReg = AllocReg();
+    StoreAccumulator(prop, propReg);
+
+    return propReg;
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/pandagen.h b/es2panda/compiler/core/pandagen.h
new file mode 100644
index 0000000000000000000000000000000000000000..eefd2e4b24180c09cf99b988a6a7f24cd2927186
--- /dev/null
+++ b/es2panda/compiler/core/pandagen.h
@@ -0,0 +1,421 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_PANDAGEN_H
+#define ES2PANDA_COMPILER_CORE_PANDAGEN_H
+
+#include <compiler/core/envScope.h>
+#include <compiler/core/inlineCache.h>
+#include <compiler/core/regAllocator.h>
+#include <compiler/core/regScope.h>
+#include <ir/irnode.h>
+#include <lexer/token/tokenType.h>
+#include <macros.h>
+
+#include <unordered_map>
+
+namespace panda::es2panda::binder {
+class FunctionScope;
+class ScopeFindResult;
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+class AstNode;
+class ScriptFunction;
+class Statement;
+class Expression;
+class Identifier;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class FunctionBuilder;
+class CompilerContext;
+class LiteralBuffer;
+class DynamicContext;
+class CatchTable;
+
+enum class Constant {
+    JS_NAN,
+    JS_HOLE,
+    JS_INFINITY,
+    JS_UNDEFINED,
+    JS_NULL,
+    JS_TRUE,
+    JS_FALSE,
+    JS_SYMBOL,
+    JS_GLOBAL,
+};
+
+class DebugInfo {
+public:
+    explicit DebugInfo(ArenaAllocator *allocator) : variableDebugInfo(allocator->Adapter()) {};
+    DEFAULT_COPY_SEMANTIC(DebugInfo);
+    DEFAULT_MOVE_SEMANTIC(DebugInfo);
+    ~DebugInfo() = default;
+
+    ArenaVector<const binder::Scope *> variableDebugInfo;
+    const ir::Statement *firstStmt {};
+};
+
+class PandaGen {
+public:
+    explicit PandaGen(ArenaAllocator *allocator, CompilerContext *context, binder::FunctionScope *scope)
+        : allocator_(allocator),
+          context_(context),
+          builder_(nullptr),
+          debugInfo_(allocator_),
+          topScope_(scope),
+          scope_(topScope_),
+          rootNode_(scope->Node()),
+          insns_(allocator_->Adapter()),
+          catchList_(allocator_->Adapter()),
+          strings_(allocator_->Adapter()),
+          buffStorage_(allocator_->Adapter()),
+          sa_(this),
+          ra_(this),
+          rra_(this)
+    {
+    }
+    ~PandaGen() = default;
+    NO_COPY_SEMANTIC(PandaGen);
+    NO_MOVE_SEMANTIC(PandaGen);
+
+    inline ArenaAllocator *Allocator() const
+    {
+        return allocator_;
+    }
+
+    const ArenaSet<util::StringView> &Strings() const
+    {
+        return strings_;
+    }
+
+    const ArenaVector<CatchTable *> &CatchList() const
+    {
+        return catchList_;
+    }
+
+    binder::FunctionScope *TopScope() const
+    {
+        return topScope_;
+    }
+
+    binder::Scope *Scope() const
+    {
+        return scope_;
+    }
+
+    const ir::AstNode *RootNode() const
+    {
+        return rootNode_;
+    }
+
+    ArenaList<IRNode *> &Insns()
+    {
+        return insns_;
+    }
+
+    const ArenaList<IRNode *> &Insns() const
+    {
+        return insns_;
+    }
+
+    VReg AllocReg()
+    {
+        return usedRegs_++;
+    }
+
+    VReg NextReg() const
+    {
+        return usedRegs_;
+    }
+
+    uint32_t TotalRegsNum() const
+    {
+        return totalRegs_;
+    }
+
+    size_t LabelCount() const
+    {
+        return labelId_;
+    }
+
+    const DebugInfo &Debuginfo() const
+    {
+        return debugInfo_;
+    }
+
+    FunctionBuilder *FuncBuilder() const
+    {
+        return builder_;
+    }
+
+    EnvScope *GetEnvScope() const
+    {
+        return envScope_;
+    }
+
+    const ArenaVector<compiler::LiteralBuffer *> &BuffStorage() const
+    {
+        return buffStorage_;
+    }
+
+    uint32_t IcSize() const
+    {
+        return ic_.Size();
+    }
+
+    bool IsDebug() const;
+    uint32_t ParamCount() const;
+    uint32_t FormalParametersCount() const;
+    uint32_t InternalParamCount() const;
+    const util::StringView &InternalName() const;
+    const util::StringView &FunctionName() const;
+    binder::Binder *Binder() const;
+
+    Label *AllocLabel();
+
+    VReg LexEnv() const;
+
+    bool FunctionHasFinalizer() const;
+    void FunctionInit(CatchTable* catchTable);
+    void FunctionEnter();
+    void FunctionExit();
+
+    LiteralBuffer *NewLiteralBuffer();
+    int32_t AddLiteralBuffer(LiteralBuffer *buf);
+
+    void InitializeLexEnv(const ir::AstNode *node, VReg lexEnv);
+    void CopyFunctionArguments(const ir::AstNode *node);
+    void GetFunctionObject(const ir::AstNode *node);
+    void GetNewTarget(const ir::AstNode *node);
+    void GetThis(const ir::AstNode *node);
+    void SetThis(const ir::AstNode *node);
+    void LoadVar(const ir::Identifier *node, const binder::ScopeFindResult &result);
+    void StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDeclaration);
+
+    void StoreAccumulator(const ir::AstNode *node, VReg vreg);
+    void LoadAccFromArgs(const ir::AstNode *node);
+    void LoadObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
+
+    void LoadObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop);
+
+    void StoreObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
+    void StoreOwnProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
+    void DeleteObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
+    void LoadAccumulator(const ir::AstNode *node, VReg reg);
+    void LoadGlobalVar(const ir::AstNode *node, const util::StringView &name);
+    void StoreGlobalVar(const ir::AstNode *node, const util::StringView &name);
+    void StoreGlobalLet(const ir::AstNode *node, const util::StringView &name);
+
+    void TryLoadGlobalByValue(const ir::AstNode *node, VReg key);
+    void TryStoreGlobalByValue(const ir::AstNode *node, VReg key);
+    void TryLoadGlobalByName(const ir::AstNode *node, const util::StringView &name);
+    void TryStoreGlobalByName(const ir::AstNode *node, const util::StringView &name);
+
+    void LoadAccFromLexEnv(const ir::AstNode *node, const binder::ScopeFindResult &result);
+    void StoreAccToLexEnv(const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDeclaration);
+
+    void LoadAccumulatorString(const ir::AstNode *node, const util::StringView &str);
+    void LoadAccumulatorFloat(const ir::AstNode *node, double num);
+    void LoadAccumulatorInt(const ir::AstNode *node, int32_t num);
+    void LoadAccumulatorInt(const ir::AstNode *node, size_t num);
+
+    void LoadConst(const ir::AstNode *node, Constant id);
+    void StoreConst(const ir::AstNode *node, VReg reg, Constant id);
+    void MoveVreg(const ir::AstNode *node, VReg vd, VReg vs);
+
+    void SetLabel(const ir::AstNode *node, Label *label);
+    void Branch(const ir::AstNode *node, class Label *label);
+    bool CheckControlFlowChange();
+    Label *ControlFlowChangeBreak(const ir::Identifier *label = nullptr);
+    Label *ControlFlowChangeContinue(const ir::Identifier *label);
+
+    void Condition(const ir::AstNode *node, lexer::TokenType op, VReg lhs, class Label *ifFalse);
+    void Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand);
+    void Binary(const ir::AstNode *node, lexer::TokenType op, VReg lhs);
+
+    void BranchIfUndefined(const ir::AstNode *node, class Label *target);
+    void BranchIfNotUndefined(const ir::AstNode *node, class Label *target);
+    void BranchIfHole(const ir::AstNode *node, class Label *target);
+    void BranchIfTrue(const ir::AstNode *node, class Label *target);
+    void BranchIfNotTrue(const ir::AstNode *node, class Label *target);
+    void BranchIfFalse(const ir::AstNode *node, class Label *target);
+    void BranchIfCoercible(const ir::AstNode *node, class Label *target);
+
+    void EmitThrow(const ir::AstNode *node);
+    void EmitRethrow(const ir::AstNode *node);
+    void EmitReturn(const ir::AstNode *node);
+    void EmitReturnUndefined(const ir::AstNode *node);
+    void ValidateClassDirectReturn(const ir::AstNode *node);
+    void DirectReturn(const ir::AstNode *node);
+    void ImplicitReturn(const ir::AstNode *node);
+    void EmitAwait(const ir::AstNode *node);
+
+    void CallThis(const ir::AstNode *node, VReg startReg, size_t argCount);
+    void Call(const ir::AstNode *node, VReg startReg, size_t argCount);
+    void CallSpread(const ir::AstNode *node, VReg func, VReg thisReg, VReg args);
+    void SuperCall(const ir::AstNode *node, VReg startReg, size_t argCount);
+    void SuperCallSpread(const ir::AstNode *node, VReg vs);
+
+    void LoadHomeObject(const ir::AstNode *node);
+    void NewObject(const ir::AstNode *node, VReg startReg, size_t argCount);
+    void DefineFunction(const ir::AstNode *node, const ir::ScriptFunction *realNode, const util::StringView &name);
+
+    void TypeOf(const ir::AstNode *node);
+    void NewObjSpread(const ir::AstNode *node, VReg obj, VReg target);
+    void GetUnmappedArgs(const ir::AstNode *node);
+
+    void Negate(const ir::AstNode *node);
+    void ToBoolean(const ir::AstNode *node);
+    void ToNumber(const ir::AstNode *node, VReg arg);
+
+    void CreateGeneratorObj(const ir::AstNode *node, VReg funcObj);
+    void ResumeGenerator(const ir::AstNode *node, VReg genObj);
+    void GetResumeMode(const ir::AstNode *node, VReg genObj);
+
+    void AsyncFunctionEnter(const ir::AstNode *node);
+    void AsyncFunctionAwait(const ir::AstNode *node, VReg asyncFuncObj);
+    void AsyncFunctionResolve(const ir::AstNode *node, VReg asyncFuncObj);
+    void AsyncFunctionReject(const ir::AstNode *node, VReg asyncFuncObj);
+
+    void GetMethod(const ir::AstNode *node, VReg obj, const util::StringView &name);
+    void GeneratorYield(const ir::AstNode *node, VReg genObj);
+    void GeneratorComplete(const ir::AstNode *node, VReg genObj);
+    void CreateAsyncGeneratorObj(const ir::AstNode *node, VReg funcObj);
+    void CreateIterResultObject(const ir::AstNode *node, bool done);
+    void SuspendGenerator(const ir::AstNode *node, VReg genObj);
+    void SuspendAsyncGenerator(const ir::AstNode *node, VReg asyncGenObj);
+
+    void AsyncGeneratorResolve(const ir::AstNode *node, VReg asyncGenObj);
+    void AsyncGeneratorReject(const ir::AstNode *node, VReg asyncGenObj);
+
+    void GetTemplateObject(const ir::AstNode *node, VReg value);
+    void CopyRestArgs(const ir::AstNode *node, uint32_t index);
+
+    void GetPropIterator(const ir::AstNode *node);
+    void GetNextPropName(const ir::AstNode *node, VReg iter);
+    void CreateEmptyObject(const ir::AstNode *node);
+    void CreateObjectWithBuffer(const ir::AstNode *node, uint32_t idx);
+    void CreateObjectHavingMethod(const ir::AstNode *node, uint32_t idx);
+    void SetObjectWithProto(const ir::AstNode *node, VReg proto, VReg obj);
+    void CopyDataProperties(const ir::AstNode *node, VReg dst, VReg src);
+    void DefineGetterSetterByValue(const ir::AstNode *node, VReg obj, VReg name, VReg getter, VReg setter,
+                                   bool setName);
+    void CreateEmptyArray(const ir::AstNode *node);
+    void CreateArray(const ir::AstNode *node, const ArenaVector<ir::Expression *> &elements, VReg obj);
+    void CreateArrayWithBuffer(const ir::AstNode *node, uint32_t idx);
+    void StoreArraySpread(const ir::AstNode *node, VReg array, VReg index);
+
+    void ThrowIfNotObject(const ir::AstNode *node);
+    void ThrowThrowNotExist(const ir::AstNode *node);
+    void GetIterator(const ir::AstNode *node);
+    void GetAsyncIterator(const ir::AstNode *node);
+
+    void CreateObjectWithExcludedKeys(const ir::AstNode *node, VReg obj, VReg argStart, size_t argCount);
+    void ThrowObjectNonCoercible(const ir::AstNode *node);
+    void CloseIterator(const ir::AstNode *node, VReg iter);
+    void DefineClassWithBuffer(const ir::AstNode *node, const util::StringView &ctorId, int32_t litIdx, VReg lexenv,
+                               VReg base);
+
+    void ImportModule(const ir::AstNode *node, const util::StringView &name);
+    void LoadModuleVariable(const ir::AstNode *node, VReg module, const util::StringView &name);
+    void StoreModuleVar(const ir::AstNode *node, const util::StringView &name);
+    void CopyModule(const ir::AstNode *node, VReg module);
+
+    void StSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key);
+    void LdSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key);
+    void StSuperByValue(const ir::AstNode *node, VReg obj, VReg prop);
+    void LdSuperByValue(const ir::AstNode *node, VReg obj, VReg prop);
+    void StoreSuperProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
+    void LoadSuperProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
+
+    void LdLexEnv(const ir::AstNode *node);
+    void PopLexEnv(const ir::AstNode *node);
+    void CopyLexEnv(const ir::AstNode *node);
+    void NewLexEnv(const ir::AstNode *node, uint32_t num);
+    void LoadLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot);
+    void StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot);
+
+    void ThrowIfSuperNotCorrectCall(const ir::AstNode *node, int64_t num);
+    void ThrowUndefinedIfHole(const ir::AstNode *node, const util::StringView &name);
+    void ThrowConstAssignment(const ir::AstNode *node, const util::StringView &name);
+
+    uint32_t TryDepth() const;
+    CatchTable *CreateCatchTable();
+    void SortCatchTables();
+
+    void LoadObjByIndex(const ir::AstNode *node, VReg obj, int64_t index);
+    void LoadObjByValue(const ir::AstNode *node, VReg obj, VReg prop);
+
+    void StoreObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop);
+    void StoreObjByIndex(const ir::AstNode *node, VReg obj, int64_t index);
+    void StoreObjByValue(const ir::AstNode *node, VReg obj, VReg prop);
+
+    void StOwnByName(const ir::AstNode *node, VReg obj, const util::StringView &prop);
+    void StOwnByValue(const ir::AstNode *node, VReg obj, VReg prop);
+    void StOwnByIndex(const ir::AstNode *node, VReg obj, int64_t index);
+
+    static Operand ToNamedPropertyKey(const ir::Expression *prop, bool isComputed);
+    Operand ToPropertyKey(const ir::Expression *prop, bool isComputed);
+    VReg LoadPropertyKey(const ir::Expression *prop, bool isComputed);
+
+    void SetFirstStmt(const ir::Statement *stmt)
+    {
+        debugInfo_.firstStmt = stmt;
+    }
+
+    [[noreturn]] static void Unimplemented()
+    {
+        throw Error(ErrorType::GENERIC, "Unimplemented code path");
+    }
+
+private:
+    ArenaAllocator *allocator_;
+    CompilerContext *context_;
+    FunctionBuilder *builder_;
+    DebugInfo debugInfo_;
+    binder::FunctionScope *topScope_;
+    binder::Scope *scope_;
+    const ir::AstNode *rootNode_;
+    ArenaList<IRNode *> insns_;
+    ArenaVector<CatchTable *> catchList_;
+    ArenaSet<util::StringView> strings_;
+    ArenaVector<LiteralBuffer *> buffStorage_;
+    EnvScope *envScope_ {};
+    DynamicContext *dynamicContext_ {};
+    InlineCache ic_;
+    SimpleAllocator sa_;
+    RegAllocator ra_;
+    RangeRegAllocator rra_;
+
+    uint32_t usedRegs_ {0};
+    uint32_t totalRegs_ {0};
+    friend class ScopeContext;
+    friend class RegScope;
+    friend class LocalRegScope;
+    friend class LoopRegScope;
+    friend class ParamRegScope;
+    friend class FunctionRegScope;
+    friend class EnvScope;
+    friend class LoopEnvScope;
+    friend class DynamicContext;
+    size_t labelId_ {0};
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/regAllocator.cpp b/es2panda/compiler/core/regAllocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ed5763f5499b520da2aff1128a28b73cacc06a7
--- /dev/null
+++ b/es2panda/compiler/core/regAllocator.cpp
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "regAllocator.h"
+
+#include <compiler/core/pandagen.h>
+
+#include <algorithm>
+
+namespace panda::es2panda::compiler {
+
+// RegAllocatorBase
+
+void AllocatorBase::PushBack(IRNode *ins)
+{
+    pg_->Insns().push_back(ins);
+}
+
+ArenaAllocator *AllocatorBase::Allocator() const
+{
+    return pg_->Allocator();
+}
+
+// SimpleAllocator
+
+Label *SimpleAllocator::AllocLabel(std::string &&id)
+{
+    const auto *lastInsNode = pg_->Insns().empty() ? FIRST_NODE_OF_FUNCTION : pg_->Insns().back()->Node();
+    return Alloc<Label>(lastInsNode, std::move(id));
+}
+
+// FrontAllocator
+
+FrontAllocator::FrontAllocator(PandaGen *pg)
+    : AllocatorBase(pg), insn_(std::move(pg_->Insns()), pg_->Allocator()->Adapter())
+{
+}
+
+FrontAllocator::~FrontAllocator()
+{
+    pg_->Insns().splice(pg_->Insns().end(), std::move(insn_));
+}
+
+// RegAllocatorBase
+
+VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
+{
+    VReg spillReg = pg_->AllocReg();
+    VReg origin = spillIndex_++;
+
+    Add<MovDyn>(ins->Node(), spillReg, origin);
+    Add<MovDyn>(ins->Node(), origin, reg);
+
+    return origin;
+}
+
+void RegAllocatorBase::Restore(IRNode *ins)
+{
+    spillIndex_--;
+    VReg spillReg = spillIndex_;
+    VReg origin = regEnd_ + spillIndex_;
+
+    Add<MovDyn>(ins->Node(), origin, spillReg);
+}
+
+// RegAllocator
+
+void RegAllocator::Run(IRNode *ins)
+{
+    ASSERT(spillIndex_ == 0);
+    std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
+    auto regCnt = ins->Registers(&regs);
+    auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+
+    if (CheckRegIndices(ins, registers)) {
+        PushBack(ins);
+        return;
+    }
+
+    RegScope regScope(pg_);
+
+    regEnd_ = pg_->NextReg();
+
+    for (auto *reg : registers) {
+        if (IsRegisterCorrect(reg)) {
+            continue;
+        }
+
+        const auto actualReg = *reg;
+        *reg = Spill(ins, actualReg);
+    }
+
+    PushBack(ins);
+
+    while (spillIndex_ != 0) {
+        Restore(ins);
+    }
+}
+
+// RangeRegAllocator
+
+void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
+{
+    ASSERT(spillIndex_ == 0);
+    const auto rangeEnd = rangeStart + argCount;
+
+    std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
+    auto regCnt = ins->Registers(&regs);
+    auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+
+    if (CheckRegIndices(ins, registers)) {
+        PushBack(ins);
+        return;
+    }
+
+    RegScope regScope(pg_);
+
+    regEnd_ = pg_->NextReg();
+
+    auto *iter = registers.begin();
+    auto *iterEnd = iter + registers.size() - 1;
+
+    while (iter != iterEnd) {
+        VReg *reg = *iter;
+
+        const auto actualReg = *reg;
+        *reg = Spill(ins, actualReg);
+        iter++;
+    }
+
+    VReg *regStartReg = *iter;
+    VReg reg = rangeStart++;
+    *regStartReg = Spill(ins, reg);
+
+    while (rangeStart != rangeEnd) {
+        reg = rangeStart++;
+        Spill(ins, reg);
+    }
+
+    PushBack(ins);
+
+    while (spillIndex_ != 0) {
+        Restore(ins);
+    }
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/regAllocator.h b/es2panda/compiler/core/regAllocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec7bfefc6382d6886e243e69f430db24178f97a5
--- /dev/null
+++ b/es2panda/compiler/core/regAllocator.h
@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_REG_ALLOCATOR_H
+#define ES2PANDA_COMPILER_CORE_REG_ALLOCATOR_H
+
+#include <gen/isa.h>
+#include <macros.h>
+
+namespace panda::es2panda::ir {
+class AstNode;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class AllocatorBase {
+public:
+    explicit AllocatorBase(PandaGen *pg) : pg_(pg) {};
+    NO_COPY_SEMANTIC(AllocatorBase);
+    NO_MOVE_SEMANTIC(AllocatorBase);
+    ~AllocatorBase() = default;
+
+protected:
+    void PushBack(IRNode *ins);
+    ArenaAllocator *Allocator() const;
+
+    template <typename T, typename... Args>
+    T *Alloc(const ir::AstNode *node, Args &&... args)
+    {
+        return Allocator()->New<T>(node, std::forward<Args>(args)...);
+    }
+
+    template <typename T, typename... Args>
+    void Add(const ir::AstNode *node, Args &&... args)
+    {
+        return PushBack(Alloc<T>(node, std::forward<Args>(args)...));
+    }
+
+    PandaGen *pg_;
+};
+
+class SimpleAllocator : public AllocatorBase {
+public:
+    explicit SimpleAllocator(PandaGen *pg) : AllocatorBase(pg) {};
+    NO_COPY_SEMANTIC(SimpleAllocator);
+    NO_MOVE_SEMANTIC(SimpleAllocator);
+    ~SimpleAllocator() = default;
+
+    Label *AllocLabel(std::string &&id);
+    void AddLabel(Label *label)
+    {
+        PushBack(label);
+    }
+
+    template <typename T, typename... Args>
+    void Emit(const ir::AstNode *node, Args &&... args)
+    {
+        Add<T>(node, std::forward<Args>(args)...);
+    }
+};
+
+class FrontAllocator : public AllocatorBase {
+public:
+    explicit FrontAllocator(PandaGen *pg);
+    NO_COPY_SEMANTIC(FrontAllocator);
+    NO_MOVE_SEMANTIC(FrontAllocator);
+    ~FrontAllocator();
+
+private:
+    ArenaList<IRNode *> insn_;
+};
+
+class RegAllocatorBase : public AllocatorBase {
+public:
+    explicit RegAllocatorBase(PandaGen *pg) : AllocatorBase(pg) {}
+    NO_COPY_SEMANTIC(RegAllocatorBase);
+    NO_MOVE_SEMANTIC(RegAllocatorBase);
+    ~RegAllocatorBase() = default;
+
+protected:
+    inline bool CheckRegIndices(IRNode *ins, const Span<VReg *> &registers)
+    {
+        Formats formats = ins->GetFormats();
+        limit_ = 0;
+
+        for (const auto &format : formats) {
+            for (const auto &formatItem : format.GetFormatItem()) {
+                if (formatItem.IsVReg()) {
+                    limit_ = 1 << formatItem.Bitwidth();
+                    break;
+                }
+            }
+
+            if (std::all_of(registers.begin(), registers.end(),
+                            [this](const VReg *reg) { return IsRegisterCorrect(reg); })) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    inline bool IsRegisterCorrect(const VReg *reg) const
+    {
+        return *reg < limit_;
+    }
+
+    VReg Spill(IRNode *ins, VReg reg);
+    void Restore(IRNode *ins);
+
+    VReg spillIndex_ {0};
+    VReg regEnd_ {0};
+    size_t limit_ {0};
+};
+
+class RegAllocator : public RegAllocatorBase {
+public:
+    explicit RegAllocator(PandaGen *pg) : RegAllocatorBase(pg) {}
+    NO_COPY_SEMANTIC(RegAllocator);
+    NO_MOVE_SEMANTIC(RegAllocator);
+    ~RegAllocator() = default;
+
+    template <typename T, typename... Args>
+    void Emit(const ir::AstNode *node, Args &&... args)
+    {
+        auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
+        Run(ins);
+    }
+
+private:
+    void Run(IRNode *ins);
+};
+
+class RangeRegAllocator : public RegAllocatorBase {
+public:
+    explicit RangeRegAllocator(PandaGen *pg) : RegAllocatorBase(pg) {}
+    NO_COPY_SEMANTIC(RangeRegAllocator);
+    NO_MOVE_SEMANTIC(RangeRegAllocator);
+    ~RangeRegAllocator() = default;
+
+    template <typename T, typename... Args>
+    void Emit(const ir::AstNode *node, VReg rangeStart, size_t argCount, Args &&... args)
+    {
+        auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
+        Run(ins, rangeStart, argCount);
+    }
+
+private:
+    void Run(IRNode *ins, VReg rangeStart, size_t argCount);
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/regScope.cpp b/es2panda/compiler/core/regScope.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..588340ed6b4b47818e86663c4e2567f64498c294
--- /dev/null
+++ b/es2panda/compiler/core/regScope.cpp
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "regScope.h"
+
+#include <binder/binder.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <compiler/base/hoisting.h>
+#include <compiler/core/compilerContext.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/moduleContext.h>
+
+namespace panda::es2panda::compiler {
+
+// RegScope
+
+RegScope::RegScope(PandaGen *pg) : pg_(pg), regBase_(pg_->usedRegs_) {}
+
+RegScope::~RegScope()
+{
+    pg_->totalRegs_ = std::max(pg_->totalRegs_, pg_->usedRegs_);
+    pg_->usedRegs_ = regBase_;
+}
+
+void RegScope::DebuggerCloseScope()
+{
+    if (!pg_->IsDebug()) {
+        return;
+    }
+
+    pg_->scope_->SetScopeEnd(pg_->insns_.back());
+}
+
+// LocalRegScope
+
+LocalRegScope::LocalRegScope(PandaGen *pg) : RegScope(pg) {}
+
+LocalRegScope::LocalRegScope(PandaGen *pg, binder::Scope *scope) : RegScope(pg)
+{
+    prevScope_ = pg_->scope_;
+    pg_->scope_ = scope;
+
+    for (const auto &[_, var] : scope->Bindings()) {
+        (void)_;
+        if (!var->LexicalBound() && var->IsLocalVariable()) {
+            var->AsLocalVariable()->BindVReg(pg->AllocReg());
+        }
+    }
+
+    if (pg_->IsDebug()) {
+        pg_->scope_->SetScopeStart(pg_->insns_.back());
+        pg_->debugInfo_.variableDebugInfo.push_back(pg_->scope_);
+    }
+
+    Hoisting::Hoist(pg_);
+}
+
+LocalRegScope::~LocalRegScope()
+{
+    if (!prevScope_) {
+        return;
+    }
+
+    DebuggerCloseScope();
+
+    pg_->scope_ = prevScope_;
+}
+
+// FunctionRegScope
+
+FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->Allocator()->New<EnvScope>())
+{
+    ASSERT(pg_->Scope()->IsFunctionVariableScope());
+    ASSERT(pg_->NextReg() == binder::Binder::MANDATORY_PARAM_FUNC_REG);
+
+    const auto *funcScope = pg_->Scope()->AsFunctionVariableScope();
+
+    for (auto *param : funcScope->ParamScope()->Params()) {
+        VReg paramReg = pg_->AllocReg();
+        if (!param->LexicalBound()) {
+            param->BindVReg(paramReg);
+        }
+    }
+
+    envScope_->Initialize(pg_, pg->AllocReg());
+
+    for (const auto &[_, var] : funcScope->Bindings()) {
+        (void)_;
+        if (var->Declaration()->IsParameterDecl()) {
+            continue;
+        }
+
+        if (!var->LexicalBound() && var->IsLocalVariable()) {
+            var->AsLocalVariable()->BindVReg(pg->AllocReg());
+        }
+    }
+
+    if (pg_->IsDebug()) {
+        pg_->debugInfo_.variableDebugInfo.push_back(funcScope);
+    }
+
+    pg_->LoadAccFromArgs(pg_->rootNode_);
+
+    if (funcScope->IsModuleScope()) {
+        ModuleContext::Compile(pg_, pg_->scope_->AsModuleScope());
+    }
+
+    Hoisting::Hoist(pg);
+}
+
+FunctionRegScope::~FunctionRegScope()
+{
+    if (pg_->IsDebug()) {
+        pg_->topScope_->SetScopeStart(pg_->insns_.front());
+    }
+
+    DebuggerCloseScope();
+
+    envScope_->~EnvScope();
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/regScope.h b/es2panda/compiler/core/regScope.h
new file mode 100644
index 0000000000000000000000000000000000000000..a34029c4f04ae87af4ab2267e52e3a5109a5196f
--- /dev/null
+++ b/es2panda/compiler/core/regScope.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_REG_SCOPE_H
+#define ES2PANDA_COMPILER_CORE_REG_SCOPE_H
+
+#include <macros.h>
+#include <binder/scope.h>
+
+namespace panda::es2panda::ir {
+class AstNode;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class EnvScope;
+class PandaGen;
+
+class RegScope {
+public:
+    explicit RegScope(PandaGen *pg);
+    NO_COPY_SEMANTIC(RegScope);
+    NO_MOVE_SEMANTIC(RegScope);
+    ~RegScope();
+
+    void *operator new(size_t) = delete;
+    void *operator new[](size_t) = delete;
+
+protected:
+    void DebuggerCloseScope();
+
+    PandaGen *pg_;
+    uint32_t regBase_;
+};
+
+class LocalRegScope : public RegScope {
+public:
+    explicit LocalRegScope(PandaGen *pg, binder::Scope *scope);
+    explicit LocalRegScope(PandaGen *pg);
+    NO_COPY_SEMANTIC(LocalRegScope);
+    NO_MOVE_SEMANTIC(LocalRegScope);
+    ~LocalRegScope();
+
+    void *operator new(size_t) = delete;
+    void *operator new[](size_t) = delete;
+
+private:
+    binder::Scope *prevScope_ {};
+};
+
+class LoopRegScope : public RegScope {
+public:
+    explicit LoopRegScope(PandaGen *pg, binder::LoopScope *scope);
+    NO_COPY_SEMANTIC(LoopRegScope);
+    NO_MOVE_SEMANTIC(LoopRegScope);
+    ~LoopRegScope();
+
+    void *operator new(size_t) = delete;
+    void *operator new[](size_t) = delete;
+
+private:
+    binder::Scope *prevScope_ {};
+};
+
+class FunctionRegScope : public RegScope {
+public:
+    explicit FunctionRegScope(PandaGen *pg);
+    NO_COPY_SEMANTIC(FunctionRegScope);
+    NO_MOVE_SEMANTIC(FunctionRegScope);
+    ~FunctionRegScope();
+
+    void *operator new(size_t) = delete;
+    void *operator new[](size_t) = delete;
+
+private:
+    EnvScope *envScope_;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/core/switchBuilder.cpp b/es2panda/compiler/core/switchBuilder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6dfa51d8fbc4d16f4ca50fca8765fa69f6d97a32
--- /dev/null
+++ b/es2panda/compiler/core/switchBuilder.cpp
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "switchBuilder.h"
+
+#include <ir/expression.h>
+#include <ir/statements/switchStatement.h>
+#include <ir/statements/switchCaseStatement.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/labelTarget.h>
+#include <typescript/checker.h>
+
+namespace panda::es2panda::compiler {
+// SwitchBuilder
+
+SwitchBuilder::SwitchBuilder(PandaGen *pg, const ir::SwitchStatement *stmt)
+    : pg_(pg), end_(pg->AllocLabel()), labelCtx_(pg, LabelTarget(end_, LabelTarget::BREAK_LABEL)), stmt_(stmt)
+{
+    for (size_t i = 0; i < stmt_->Cases().size(); i++) {
+        caseLabels_.push_back(pg_->AllocLabel());
+    }
+}
+
+SwitchBuilder::~SwitchBuilder()
+{
+    pg_->SetLabel(stmt_, end_);
+}
+
+void SwitchBuilder::SetCaseTarget(uint32_t index)
+{
+    pg_->SetLabel(stmt_->Cases()[index], caseLabels_[index]);
+}
+
+void SwitchBuilder::CompileTagOfSwitch(VReg tag)
+{
+    stmt_->Discriminant()->Compile(pg_);
+    pg_->StoreAccumulator(stmt_->Discriminant(), tag);
+}
+
+void SwitchBuilder::CompileCaseStatements(uint32_t index)
+{
+    for (const auto *stmt : stmt_->Cases()[index]->Consequent()) {
+        stmt->Compile(pg_);
+    }
+}
+
+void SwitchBuilder::JumpIfCase(VReg tag, uint32_t index)
+{
+    const ir::SwitchCaseStatement *caseTarget = stmt_->Cases()[index];
+    caseTarget->Test()->Compile(pg_);
+    pg_->Condition(caseTarget, lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL, tag, caseLabels_[index]);
+}
+
+void SwitchBuilder::JumpToDefault(uint32_t defaultIndex)
+{
+    const ir::SwitchCaseStatement *defaultTarget = stmt_->Cases()[defaultIndex];
+    pg_->Branch(defaultTarget, caseLabels_[defaultIndex]);
+}
+
+void SwitchBuilder::Break()
+{
+    pg_->Branch(stmt_, end_);
+}
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/switchBuilder.h b/es2panda/compiler/core/switchBuilder.h
new file mode 100644
index 0000000000000000000000000000000000000000..cea6db1b5dcb6be513c89fcb5f980ef38fff8a89
--- /dev/null
+++ b/es2panda/compiler/core/switchBuilder.h
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_CORE_SWITCH_BUILDER_H
+#define ES2PANDA_COMPILER_CORE_SWITCH_BUILDER_H
+
+#include <ir/irnode.h>
+#include <compiler/core/dynamicContext.h>
+
+namespace panda::es2panda::ir {
+class SwitchStatement;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+class Label;
+
+class SwitchBuilder {
+public:
+    SwitchBuilder(PandaGen *pg, const ir::SwitchStatement *stmt);
+    NO_COPY_SEMANTIC(SwitchBuilder);
+    NO_MOVE_SEMANTIC(SwitchBuilder);
+    ~SwitchBuilder();
+
+    void SetCaseTarget(uint32_t index);
+    void CompileTagOfSwitch(VReg tag);
+    void CompileCaseStatements(uint32_t index);
+    void JumpIfCase(VReg tag, uint32_t index);
+    void JumpToDefault(uint32_t defaultIndex);
+    void Break();
+
+private:
+    PandaGen *pg_;
+    Label *end_;
+    LabelContext labelCtx_;
+    const ir::SwitchStatement *stmt_;
+    std::vector<Label *> caseLabels_;
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/debugger/debuginfoDumper.cpp b/es2panda/compiler/debugger/debuginfoDumper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..24f9745a6173d477238535bf867bd98eeeaf9610
--- /dev/null
+++ b/es2panda/compiler/debugger/debuginfoDumper.cpp
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "debuginfoDumper.h"
+
+#include <macros.h>
+
+#include <sstream>
+#include <string>
+
+namespace panda::es2panda::debuginfo {
+
+DebugInfoDumper::DebugInfoDumper(const pandasm::Program *prog) : prog_(prog) {}
+
+static const char *PutComma(bool comma)
+{
+    return comma ? "," : "";
+}
+
+template <typename T>
+void DebugInfoDumper::WrapArray(const char *name, const std::vector<T> &array, bool comma)
+{
+    ss_ << std::endl;
+    Indent();
+    ss_ << "\"" << name << "\": "
+        << "[";
+
+    if (array.empty()) {
+        ss_ << "]" << PutComma(comma);
+        return;
+    }
+
+    ss_ << "\n";
+    indent_++;
+    // dump VariableDebugInfo in reverse order to match ts2panda
+    // NOLINTNEXTLINE
+    if constexpr (std::is_same_v<T, pandasm::debuginfo::LocalVariable>) {
+        typename std::vector<T>::const_reverse_iterator elem;
+        for (elem = array.rbegin(); elem != array.rend(); ++elem) {
+            Indent();
+            WriteVariableInfo(*elem);
+            (std::next(elem) == array.rend()) ? ss_ << "" : ss_ << ",";
+            ss_ << "\n";
+        }
+        // NOLINTNEXTLINE
+    } else {
+        typename std::vector<T>::const_iterator elem;
+        for (elem = array.begin(); elem != array.end(); ++elem) {
+            Indent();
+            // NOLINTNEXTLINE
+            if constexpr (std::is_same_v<T, pandasm::Ins>) {
+                WriteIns(*elem);
+                // NOLINTNEXTLINE
+            } else if constexpr (std::is_same_v<T, pandasm::Function::Parameter>) {
+                ss_ << "\"" << (*elem).type.GetName() << "\"";
+                // NOLINTNEXTLINE
+            } else if constexpr (std::is_same_v<T, std::string>) {
+                ss_ << "\"" << *elem << "\"";
+                // NOLINTNEXTLINE
+            } else if constexpr (std::is_same_v<T, std::variant<int64_t, double>>) {
+                if (std::holds_alternative<int64_t>(*elem)) {
+                    ss_ << std::to_string(std::get<int64_t>(*elem));
+                } else {
+                    ss_ << std::to_string(std::get<double>(*elem));
+                }
+                // NOLINTNEXTLINE
+            } else {
+                ss_ << std::to_string(*elem);
+            }
+
+            (std::next(elem) == array.end()) ? ss_ << "" : ss_ << ",";
+            ss_ << "\n";
+        }
+    }
+
+    indent_--;
+    Indent();
+
+    ss_ << "]" << PutComma(comma);
+}
+
+void DebugInfoDumper::WriteIns(const pandasm::Ins &ins)
+{
+    ss_ << "{";
+    {
+        pandasm::Ins insCopy;
+        insCopy.opcode = ins.opcode;
+        insCopy.set_label = ins.set_label;
+        insCopy.label = ins.label;
+        WriteProperty("opcode", insCopy.ToString());
+    }
+    indent_++;
+    WrapArray("regs", ins.regs);
+    WrapArray("ids", ins.ids);
+    WrapArray("imms", ins.imms);
+    ss_ << std::endl;
+    Indent();
+    ss_ << "\"label\": "
+        << "\"" << ins.label << "\",";
+    WritePosInfo(ins.ins_debug);
+    indent_--;
+    Indent();
+    ss_ << "}";
+}
+
+void DebugInfoDumper::WriteMetaData(const std::vector<pandasm::AnnotationData> &metaData)
+{
+    for (const auto &it : metaData) {
+        for (const auto &elem : it.GetElements()) {
+            pandasm::ScalarValue *value = elem.GetValue()->GetAsScalar();
+            if (value->GetType() == pandasm::Value::Type::STRING) {
+                WriteProperty(elem.GetName().c_str(), value->GetValue<std::string>(), false);
+            } else if (value->GetType() == pandasm::Value::Type::U32) {
+                WriteProperty(elem.GetName().c_str(), value->GetValue<size_t>());
+            }
+        }
+    }
+}
+
+void DebugInfoDumper::WritePosInfo(const pandasm::debuginfo::Ins &posInfo)
+{
+    ss_ << std::endl;
+    Indent();
+    ss_ << "\"debug_pos_info\": {";
+    WriteProperty("boundLeft", posInfo.bound_left);
+    WriteProperty("boundRight", posInfo.bound_right);
+    WriteProperty("sourecLineNum", static_cast<int32_t>(posInfo.line_number));
+    WriteProperty("wholeLine", posInfo.whole_line, false);
+    Indent();
+    ss_ << "}" << std::endl;
+}
+
+void DebugInfoDumper::WriteVariableInfo(const pandasm::debuginfo::LocalVariable &localVariableDebug)
+{
+    ss_ << "{";
+    WriteProperty("name", localVariableDebug.name);
+    WriteProperty("signature", localVariableDebug.signature);
+    WriteProperty("signatureType", localVariableDebug.signature_type);
+    WriteProperty("reg", localVariableDebug.reg);
+    WriteProperty("start", static_cast<size_t>(localVariableDebug.start));
+    WriteProperty("length", static_cast<size_t>(localVariableDebug.length), false);
+    Indent();
+    ss_ << "}";
+}
+
+void DebugInfoDumper::Dump()
+{
+    ss_ << "{\n";
+    indent_++;
+    Indent();
+    ss_ << "\"functions\": [" << std::endl;
+
+    auto iter = prog_->function_table.begin();
+
+    for (; iter != prog_->function_table.end(); ++iter) {
+        indent_++;
+        Indent();
+        ss_ << "{";
+        WriteProperty("name", iter->first);
+        ss_ << std::endl;
+
+        indent_++;
+        Indent();
+        ss_ << "\"signature\": {";
+        WriteProperty("retType", iter->second.return_type.GetName());
+        indent_++;
+        WrapArray("params", iter->second.params, false);
+        indent_ -= 2U;
+        ss_ << std::endl;
+        Indent();
+        ss_ << "},";
+
+        WrapArray("ins", iter->second.ins);
+        WrapArray("variables", iter->second.local_variable_debug);
+        WriteProperty("sourceFile", iter->second.source_file);
+        WriteProperty("sourceCode", iter->second.source_code);
+        // icSize - parameterLength - funcName
+        WriteMetaData(iter->second.metadata->GetAnnotations());
+
+        indent_--;
+        Indent();
+        ss_ << "}";
+
+        if (std::next(iter) != prog_->function_table.end()) {
+            ss_ << ",";
+        }
+
+        ss_ << std::endl;
+    }
+
+    indent_--;
+    Indent();
+    ss_ << "]" << std::endl;
+    ss_ << "}";
+    ss_ << std::endl;
+    std::cout << ss_.str();
+}
+
+void DebugInfoDumper::WriteProperty(const char *key, const Value &value, bool comma)
+{
+    ss_ << std::endl;
+    indent_++;
+    Indent();
+    ss_ << "\"" << key << "\": ";
+    if (std::holds_alternative<std::string>(value)) {
+        ss_ << "\"" << std::get<std::string>(value) << "\"";
+    } else if (std::holds_alternative<size_t>(value)) {
+        ss_ << std::to_string(std::get<size_t>(value));
+    } else if (std::holds_alternative<int32_t>(value)) {
+        ss_ << std::to_string(std::get<int32_t>(value));
+    }
+
+    comma ? ss_ << "," : ss_ << std::endl;
+    indent_--;
+}
+
+void DebugInfoDumper::Indent()
+{
+    for (int32_t i = 0; i <= indent_; i++) {
+        ss_ << "  ";
+    }
+}
+
+}  // namespace panda::es2panda::debuginfo
diff --git a/es2panda/compiler/debugger/debuginfoDumper.h b/es2panda/compiler/debugger/debuginfoDumper.h
new file mode 100644
index 0000000000000000000000000000000000000000..a9d0aecf5ad882c84432dd1283e0b584016b0e50
--- /dev/null
+++ b/es2panda/compiler/debugger/debuginfoDumper.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_DEBUGGER_DEBUGINFO_DUMPER_H
+#define ES2PANDA_COMPILER_DEBUGGER_DEBUGINFO_DUMPER_H
+
+#include <assembly-ins.h>
+#include <assembly-program.h>
+#include <macros.h>
+
+namespace panda::es2panda::debuginfo {
+
+using Value = std::variant<std::string, size_t, int32_t>;
+
+class DebugInfoDumper {
+public:
+    explicit DebugInfoDumper(const pandasm::Program *prog);
+    ~DebugInfoDumper() = default;
+    NO_COPY_SEMANTIC(DebugInfoDumper);
+    NO_MOVE_SEMANTIC(DebugInfoDumper);
+
+    void Dump();
+
+private:
+    template <typename T>
+    void WrapArray(const char *name, const std::vector<T> &array, bool comma = true);
+    void WriteIns(const pandasm::Ins &ins);
+    void WriteMetaData(const std::vector<pandasm::AnnotationData> &metaData);
+    void WriteProperty(const char *key, const Value &value, bool comma = true);
+    void WritePosInfo(const pandasm::debuginfo::Ins &posInfo);
+    void WriteVariableInfo(const pandasm::debuginfo::LocalVariable &localVariableDebug);
+    void Indent();
+
+    const pandasm::Program *prog_;
+    std::stringstream ss_;
+    int32_t indent_ {0};
+};
+
+}  // namespace panda::es2panda::debuginfo
+
+#endif  // UTIL_DEBUGINFO_DUMPER_H
diff --git a/es2panda/compiler/function/asyncFunctionBuilder.cpp b/es2panda/compiler/function/asyncFunctionBuilder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..acbbc790ab449ea78e45f907ad6cc3d527c0c3d5
--- /dev/null
+++ b/es2panda/compiler/function/asyncFunctionBuilder.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "asyncFunctionBuilder.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/base/catchTable.h>
+#include <ir/base/scriptFunction.h>
+
+namespace panda::es2panda::compiler {
+
+void AsyncFunctionBuilder::DirectReturn(const ir::AstNode *node) const
+{
+    pg_->AsyncFunctionResolve(node, funcObj_);
+    pg_->EmitReturn(node);
+}
+
+void AsyncFunctionBuilder::ImplicitReturn(const ir::AstNode *node) const
+{
+    pg_->LoadConst(node, Constant::JS_UNDEFINED);
+    DirectReturn(node);
+}
+
+void AsyncFunctionBuilder::Prepare(const ir::ScriptFunction *node) const
+{
+    pg_->AsyncFunctionEnter(node);
+    pg_->StoreAccumulator(node, funcObj_);
+    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
+}
+
+void AsyncFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
+{
+    const auto &labelSet = catchTable_->LabelSet();
+
+    pg_->SetLabel(node, labelSet.TryEnd());
+    pg_->SetLabel(node, labelSet.CatchBegin());
+    pg_->AsyncFunctionReject(node, funcObj_);
+    pg_->EmitReturn(node);
+    pg_->SetLabel(node, labelSet.CatchEnd());
+}
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/function/asyncFunctionBuilder.h b/es2panda/compiler/function/asyncFunctionBuilder.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd7f38a81456a69877e83c58318ab9670dec20ba
--- /dev/null
+++ b/es2panda/compiler/function/asyncFunctionBuilder.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_FUNCTION_ASYNC_FUNCTION_BUILDER_H
+#define ES2PANDA_COMPILER_FUNCTION_ASYNC_FUNCTION_BUILDER_H
+
+#include <ir/irnode.h>
+#include <compiler/function/functionBuilder.h>
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+class AsyncFunctionBuilder : public FunctionBuilder {
+public:
+    explicit AsyncFunctionBuilder(PandaGen *pg, CatchTable *catchTable) : FunctionBuilder(pg, catchTable) {}
+    ~AsyncFunctionBuilder() override = default;
+    NO_COPY_SEMANTIC(AsyncFunctionBuilder);
+    NO_MOVE_SEMANTIC(AsyncFunctionBuilder);
+
+    void Prepare(const ir::ScriptFunction *node) const override;
+    void CleanUp(const ir::ScriptFunction *node) const override;
+
+    void DirectReturn(const ir::AstNode *node) const override;
+    void ImplicitReturn(const ir::AstNode *node) const override;
+
+protected:
+    BuilderType BuilderKind() const override
+    {
+        return BuilderType::ASYNC;
+    }
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/function/asyncGeneratorFunctionBuilder.cpp b/es2panda/compiler/function/asyncGeneratorFunctionBuilder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4360cd87af39409aa8692c5872f7498320848e7
--- /dev/null
+++ b/es2panda/compiler/function/asyncGeneratorFunctionBuilder.cpp
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "asyncGeneratorFunctionBuilder.h"
+
+#include <compiler/base/catchTable.h>
+#include <compiler/core/pandagen.h>
+#include <ir/base/scriptFunction.h>
+
+namespace panda::es2panda::compiler {
+void AsyncGeneratorFunctionBuilder::Prepare(const ir::ScriptFunction *node) const
+{
+    VReg callee = FunctionReg(node);
+
+    pg_->CreateAsyncGeneratorObj(node, callee);
+    pg_->StoreAccumulator(node, funcObj_);
+    pg_->SuspendGenerator(node, funcObj_);
+    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
+}
+
+void AsyncGeneratorFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
+{
+    const auto &labelSet = catchTable_->LabelSet();
+
+    pg_->SetLabel(node, labelSet.TryEnd());
+    pg_->SetLabel(node, labelSet.CatchBegin());
+    pg_->AsyncGeneratorReject(node, funcObj_);
+    pg_->EmitReturn(node);
+    pg_->SetLabel(node, labelSet.CatchEnd());
+}
+
+void AsyncGeneratorFunctionBuilder::DirectReturn(const ir::AstNode *node) const
+{
+    pg_->AsyncGeneratorResolve(node, funcObj_);
+    pg_->EmitReturn(node);
+}
+
+void AsyncGeneratorFunctionBuilder::ImplicitReturn(const ir::AstNode *node) const
+{
+    pg_->LoadConst(node, Constant::JS_UNDEFINED);
+    DirectReturn(node);
+}
+
+void AsyncGeneratorFunctionBuilder::Yield(const ir::AstNode *node)
+{
+    Await(node);
+
+    RegScope rs(pg_);
+    VReg completionType = pg_->AllocReg();
+    VReg completionValue = pg_->AllocReg();
+
+    AsyncYield(node, completionType, completionValue);
+
+    auto *notReturnCompletion = pg_->AllocLabel();
+    auto *normalCompletion = pg_->AllocLabel();
+    auto *notThrowCompletion = pg_->AllocLabel();
+
+    // 27.6.3.8.8.a. If resumptionValue.[[Type]] is not return
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::RETURN));
+    pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notReturnCompletion);
+    // 27.6.3.8.8.b. Let awaited be Await(resumptionValue.[[Value]]).
+    pg_->LoadAccumulator(node, completionValue);
+    pg_->AsyncFunctionAwait(node, funcObj_);
+    SuspendResumeExecution(node, completionType, completionValue);
+
+    // 27.6.3.8.8.c. If awaited.[[Type]] is throw, return Completion(awaited).
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::THROW));
+
+    pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, normalCompletion);
+    pg_->LoadAccumulator(node, completionValue);
+    pg_->EmitThrow(node);
+
+    pg_->SetLabel(node, normalCompletion);
+    // 27.6.3.8.8.d. Assert: awaited.[[Type]] is normal.
+    // 27.6.3.8.8.e. Return Completion { [[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty }.
+    pg_->ControlFlowChangeBreak();
+    pg_->LoadAccumulator(node, completionValue);
+    pg_->DirectReturn(node);
+
+    pg_->SetLabel(node, notReturnCompletion);
+    // 27.6.3.8.8.a. return Completion(resumptionValue).
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::THROW));
+    pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notThrowCompletion);
+    pg_->LoadAccumulator(node, completionValue);
+    pg_->EmitThrow(node);
+    pg_->SetLabel(node, notThrowCompletion);
+    pg_->LoadAccumulator(node, completionValue);
+}
+
+IteratorType AsyncGeneratorFunctionBuilder::GeneratorKind() const
+{
+    return IteratorType::ASYNC;
+}
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/function/asyncGeneratorFunctionBuilder.h b/es2panda/compiler/function/asyncGeneratorFunctionBuilder.h
new file mode 100644
index 0000000000000000000000000000000000000000..f492da49d1f4428945821d5f1a4fae51c75c7b91
--- /dev/null
+++ b/es2panda/compiler/function/asyncGeneratorFunctionBuilder.h
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_FUNCTION_ASYNC_GENERATOR_FUNCTION_BUILDER_H
+#define ES2PANDA_COMPILER_FUNCTION_ASYNC_GENERATOR_FUNCTION_BUILDER_H
+
+#include <ir/irnode.h>
+
+#include <compiler/function/asyncFunctionBuilder.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+
+class AsyncGeneratorFunctionBuilder : public FunctionBuilder {
+public:
+    explicit AsyncGeneratorFunctionBuilder(PandaGen *pg, CatchTable *catchTable) : FunctionBuilder(pg, catchTable) {}
+    ~AsyncGeneratorFunctionBuilder() override = default;
+    NO_COPY_SEMANTIC(AsyncGeneratorFunctionBuilder);
+    NO_MOVE_SEMANTIC(AsyncGeneratorFunctionBuilder);
+
+    void Prepare(const ir::ScriptFunction *node) const override;
+    void CleanUp(const ir::ScriptFunction *node) const override;
+
+    void DirectReturn(const ir::AstNode *node) const override;
+    void ImplicitReturn(const ir::AstNode *node) const override;
+
+    void Yield(const ir::AstNode *node) override;
+
+protected:
+    BuilderType BuilderKind() const override
+    {
+        return BuilderType::ASYNC_GENERATOR;
+    }
+
+    IteratorType GeneratorKind() const override;
+};
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/function/functionBuilder.cpp b/es2panda/compiler/function/functionBuilder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eaba22a71aaada4722e54db98adba4d474341bc6
--- /dev/null
+++ b/es2panda/compiler/function/functionBuilder.cpp
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "functionBuilder.h"
+
+#include <binder/binder.h>
+#include <util/helpers.h>
+#include <ir/statement.h>
+#include <ir/base/scriptFunction.h>
+#include <compiler/base/iterators.h>
+#include <compiler/core/pandagen.h>
+
+namespace panda::es2panda::compiler {
+
+FunctionBuilder::FunctionBuilder(PandaGen *pg, CatchTable *catchTable)
+    : pg_(pg), catchTable_(catchTable), funcObj_(pg_->AllocReg())
+{
+}
+
+IteratorType FunctionBuilder::GeneratorKind() const
+{
+    return IteratorType::SYNC;
+}
+
+void FunctionBuilder::DirectReturn(const ir::AstNode *node) const
+{
+    pg_->EmitReturn(node);
+}
+
+void FunctionBuilder::ImplicitReturn(const ir::AstNode *node) const
+{
+    const auto *rootNode = pg_->RootNode();
+
+    if (!rootNode->IsScriptFunction() || !rootNode->AsScriptFunction()->IsConstructor()) {
+        pg_->EmitReturnUndefined(node);
+        return;
+    }
+
+    pg_->GetThis(rootNode);
+    pg_->ThrowIfSuperNotCorrectCall(rootNode, 0);
+    pg_->EmitReturn(node);
+}
+
+void FunctionBuilder::AsyncYield(const ir::AstNode *node, VReg completionType, VReg completionValue) const
+{
+    ASSERT(BuilderKind() == BuilderType::ASYNC_GENERATOR);
+
+    pg_->GeneratorYield(node, funcObj_);
+    pg_->SuspendAsyncGenerator(node, funcObj_);
+
+    resumeGenerator(node, completionType, completionValue);
+}
+
+void FunctionBuilder::SuspendResumeExecution(const ir::AstNode *node, VReg completionType, VReg completionValue) const
+{
+    ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR ||
+           BuilderKind() == BuilderType::GENERATOR);
+
+    pg_->SuspendGenerator(node, funcObj_);
+    resumeGenerator(node, completionType, completionValue);
+}
+
+void FunctionBuilder::resumeGenerator(const ir::AstNode *node, VReg completionType, VReg completionValue) const
+{
+    ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR ||
+           BuilderKind() == BuilderType::GENERATOR);
+
+    pg_->ResumeGenerator(node, funcObj_);
+    pg_->StoreAccumulator(node, completionValue);
+    pg_->GetResumeMode(node, funcObj_);
+    pg_->StoreAccumulator(node, completionType);
+}
+
+VReg FunctionBuilder::FunctionReg(const ir::ScriptFunction *node) const
+{
+    binder::FunctionScope *scope = node->Scope();
+    auto res = scope->Find(binder::Binder::MANDATORY_PARAM_FUNC);
+    ASSERT(res.level == 0 && res.variable->IsLocalVariable());
+    return res.variable->AsLocalVariable()->Vreg();
+}
+
+void FunctionBuilder::Await(const ir::AstNode *node)
+{
+    if (BuilderKind() == BuilderType::NORMAL) {
+        // TODO(frobert): Implement top-level await
+        PandaGen::Unimplemented();
+    }
+
+    ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR);
+
+    RegScope rs(pg_);
+    VReg completionType = pg_->AllocReg();
+    VReg completionValue = pg_->AllocReg();
+
+    pg_->AsyncFunctionAwait(node, funcObj_);
+    SuspendResumeExecution(node, completionType, completionValue);
+
+    HandleCompletion(node, completionType, completionValue);
+}
+
+void FunctionBuilder::HandleCompletion(const ir::AstNode *node, VReg completionType, VReg completionValue)
+{
+    // .return(value)
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::RETURN));
+
+    auto *notRetLabel = pg_->AllocLabel();
+    pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notRetLabel);
+    if (!handleReturn_) {
+        handleReturn_ = true;
+        pg_->ControlFlowChangeBreak();
+        handleReturn_ = false;
+    }
+
+    pg_->LoadAccumulator(node, completionValue);
+    pg_->DirectReturn(node);
+
+    // .throw(value)
+    pg_->SetLabel(node, notRetLabel);
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::THROW));
+
+    auto *not_throw_label = pg_->AllocLabel();
+    pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, not_throw_label);
+    pg_->LoadAccumulator(node, completionValue);
+    pg_->EmitThrow(node);
+
+    // .next(value)
+    pg_->SetLabel(node, not_throw_label);
+    pg_->LoadAccumulator(node, completionValue);
+}
+
+void FunctionBuilder::YieldStar(const ir::AstNode *node)
+{
+    ASSERT(BuilderKind() == BuilderType::GENERATOR || BuilderKind() == BuilderType::ASYNC_GENERATOR);
+
+    RegScope rs(pg_);
+
+    auto *loopStart = pg_->AllocLabel();
+    auto *returnCompletion = pg_->AllocLabel();
+    auto *throwCompletion = pg_->AllocLabel();
+    auto *callMethod = pg_->AllocLabel();
+    auto *normalOrThrowCompletion = pg_->AllocLabel();
+    auto *iteratorComplete = pg_->AllocLabel();
+
+    // 4. Let iteratorRecord be ? GetIterator(value, generatorKind).
+    Iterator iterator(pg_, node, GeneratorKind());
+
+    // 6. Let received be NormalCompletion(undefined).
+    VReg receivedValue = iterator.NextResult();
+    VReg receivedType = pg_->AllocReg();
+    VReg nextMethod = pg_->AllocReg();
+    VReg exitReturn = pg_->AllocReg();
+
+    pg_->StoreConst(node, receivedValue, Constant::JS_UNDEFINED);
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::NEXT));
+    pg_->StoreAccumulator(node, receivedType);
+    pg_->MoveVreg(node, nextMethod, iterator.Method());
+
+    // 7. Repeat
+    pg_->SetLabel(node, loopStart);
+    pg_->StoreConst(node, exitReturn, Constant::JS_FALSE);
+
+    // a. If received.[[Type]] is normal, then
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::NEXT));
+    pg_->Condition(node, lexer::TokenType::PUNCTUATOR_STRICT_EQUAL, receivedType, throwCompletion);
+    pg_->MoveVreg(node, iterator.Method(), nextMethod);
+    pg_->Branch(node, callMethod);
+
+    // b. Else if received.[[Type]] is throw, then
+    pg_->SetLabel(node, throwCompletion);
+    pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::THROW));
+    pg_->Condition(node, lexer::TokenType::PUNCTUATOR_STRICT_EQUAL, receivedType, returnCompletion);
+
+    // i. Let throw be ? GetMethod(iterator, "throw").
+    iterator.GetMethod("throw");
+
+    // ii. If throw is not undefined, then
+    pg_->BranchIfNotUndefined(node, callMethod);
+
+    // iii. Else,
+    // 1. NOTE: If iterator does not have a throw method, this throw is going to terminate the yield* loop. But first we
+    // need to give iterator a chance to clean up.
+    // 2. Let closeCompletion be Completion { [[Type]]: normal, [[Value]]: empty, [[Target]]: empty }.
+    // 3. If generatorKind is async, perform ? AsyncIteratorClose(iteratorRecord, closeCompletion).
+    // 4. Else, perform ? IteratorClose(iteratorRecord, closeCompletion).
+    iterator.Close(false);
+    // 5. NOTE: The next step throws a TypeError to indicate that there was a yield* protocol violation: iterator does
+    // not have a throw method.
+    // 6. Throw a TypeError exception.
+    pg_->ThrowThrowNotExist(node);
+
+    // c. Else,
+    // i. Assert: received.[[Type]] is return.
+    pg_->SetLabel(node, returnCompletion);
+    pg_->StoreConst(node, exitReturn, Constant::JS_TRUE);
+    // ii. Let return be ? GetMethod(iterator, "return").
+    iterator.GetMethod("return");
+
+    // iii. If return is undefined, then
+    pg_->BranchIfNotUndefined(node, callMethod);
+
+    // 1. If generatorKind is async, set received.[[Value]] to ? Await(received.[[Value]]).
+    pg_->ControlFlowChangeBreak();
+    pg_->LoadAccumulator(node, receivedValue);
+
+    if (GeneratorKind() == IteratorType::ASYNC) {
+        Await(node);
+    }
+
+    // 2. Return Completion(received).
+    pg_->DirectReturn(node);
+
+    pg_->SetLabel(node, callMethod);
+    // i. Let innerResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « received.[[Value]] »).
+    // 1. Let innerResult be ? Call(throw, iterator, « received.[[Value]] »).
+    // iv. Let innerReturnResult be ? Call(return, iterator, « received.[[Value]] »).
+    iterator.CallMethodWithValue();
+
+    // ii. ii. If generatorKind is async, set innerResult to ? Await(innerResult).
+    // 2. If generatorKind is async, set innerResult to ? Await(innerResult).
+    // v. If generatorKind is async, set innerReturnResult to ? Await(innerReturnResult).
+    if (GeneratorKind() == IteratorType::ASYNC) {
+        Await(node);
+    }
+
+    pg_->StoreAccumulator(node, receivedValue);
+
+    // ii. If Type(innerResult) is not Object, throw a TypeError exception.
+    // 4. If Type(innerResult) is not Object, throw a TypeError exception.
+    // vi. If Type(innerReturnResult) is not Object, throw a TypeError exception.
+    pg_->ThrowIfNotObject(node);
+
+    // iv. Let done be ? IteratorComplete(innerResult).
+    // v. Let done be ? IteratorComplete(innerResult).
+    // vii. Let done be ? IteratorComplete(innerReturnResult).
+    iterator.Complete();
+    pg_->BranchIfTrue(node, iteratorComplete);
+
+    pg_->LoadAccumulator(node, receivedValue);
+    // vi. If generatorKind is async, set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+    // 7. If generatorKind is async, set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+    // ix. If generatorKind is async, set received to AsyncGeneratorYield(? IteratorValue(innerReturnResult)).
+    if (GeneratorKind() == IteratorType::ASYNC) {
+        iterator.Value();
+        // 27.6.3.8 AsyncGeneratorYield
+        // 5. Set value to ? Await(value).
+        Await(node);
+        // 6. Set generator.[[AsyncGeneratorState]] to suspendedYield.
+        AsyncYield(node, receivedType, receivedValue);
+
+        // a. If resumptionValue.[[Type]] is not return
+        pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::RETURN));
+        pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, receivedType, loopStart);
+
+        // b. Let awaited be Await(resumptionValue.[[Value]]).
+        pg_->LoadAccumulator(node, receivedValue);
+        pg_->AsyncFunctionAwait(node, funcObj_);
+        SuspendResumeExecution(node, receivedType, receivedValue);
+
+        // c. If awaited.[[Type]] is throw, return Completion(awaited).
+        pg_->LoadAccumulatorInt(node, static_cast<int32_t>(ResumeMode::THROW));
+        // d. Assert: awaited.[[Type]] is normal.
+        // e. Return Completion { [[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty }.
+        pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, receivedType, returnCompletion);
+    } else {
+        // vii. Else, set received to GeneratorYield(innerResult).
+        // 8. Else, set received to GeneratorYield(innerResult).
+        // x. Else, set received to GeneratorYield(innerReturnResult).
+        pg_->GeneratorYield(node, funcObj_);
+        SuspendResumeExecution(node, receivedType, receivedValue);
+    }
+
+    pg_->Branch(node, loopStart);
+
+    // v. If done is true, then
+    // 6. If done is true, then
+    // viii. If done is true, then
+    pg_->SetLabel(node, iteratorComplete);
+
+    pg_->LoadAccumulator(node, exitReturn);
+    pg_->BranchIfFalse(node, normalOrThrowCompletion);
+
+    // 1. Let value be ? IteratorValue(innerReturnResult).
+    iterator.Value();
+
+    if (pg_->CheckControlFlowChange()) {
+        pg_->StoreAccumulator(node, receivedValue);
+        pg_->ControlFlowChangeBreak();
+        pg_->LoadAccumulator(node, receivedValue);
+    }
+
+    // 2. Return Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
+    pg_->DirectReturn(node);
+
+    pg_->SetLabel(node, normalOrThrowCompletion);
+    // 1. Return ? IteratorValue(innerResult).
+    // a. Return ? IteratorValue(innerResult).
+    iterator.Value();
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/function/functionBuilder.h b/es2panda/compiler/function/functionBuilder.h
new file mode 100644
index 0000000000000000000000000000000000000000..4147c49577a673a71ea7f8ee198bc1e2158443ce
--- /dev/null
+++ b/es2panda/compiler/function/functionBuilder.h
@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_FUNCTION_FUNCTION_BUILDER_H
+#define ES2PANDA_COMPILER_FUNCTION_FUNCTION_BUILDER_H
+
+#include <macros.h>
+#include <ir/irnode.h>
+
+namespace panda::es2panda::ir {
+class ScriptFunction;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+class CatchTable;
+enum class IteratorType;
+
+enum class ResumeMode {
+    RETURN,
+    THROW,
+    NEXT,
+};
+
+class FunctionBuilder {
+public:
+    enum class BuilderType {
+        NORMAL,
+        GENERATOR,
+        ASYNC,
+        ASYNC_GENERATOR,
+    };
+
+    explicit FunctionBuilder(PandaGen *pg, CatchTable *catchTable);
+    virtual ~FunctionBuilder() = default;
+    NO_COPY_SEMANTIC(FunctionBuilder);
+    NO_MOVE_SEMANTIC(FunctionBuilder);
+
+    virtual void Prepare([[maybe_unused]] const ir::ScriptFunction *node) const {};
+    virtual void CleanUp([[maybe_unused]] const ir::ScriptFunction *node) const {};
+
+    virtual void DirectReturn(const ir::AstNode *node) const;
+    virtual void ImplicitReturn(const ir::AstNode *node) const;
+
+    virtual void Await(const ir::AstNode *node);
+    virtual void YieldStar(const ir::AstNode *node);
+
+    virtual void Yield([[maybe_unused]] const ir::AstNode *node)
+    {
+        UNREACHABLE();
+    };
+
+protected:
+    virtual BuilderType BuilderKind() const
+    {
+        return BuilderType::NORMAL;
+    }
+
+    virtual IteratorType GeneratorKind() const;
+
+    void SuspendResumeExecution(const ir::AstNode *node, VReg completionType, VReg completionValue) const;
+    void AsyncYield(const ir::AstNode *node, VReg completionType, VReg completionValue) const;
+
+    VReg FunctionReg(const ir::ScriptFunction *node) const;
+    void HandleCompletion(const ir::AstNode *node, VReg completionType, VReg completionValue);
+
+    PandaGen *pg_;
+    CatchTable *catchTable_;
+    VReg funcObj_ {};
+    bool handleReturn_ {};
+
+private:
+    void resumeGenerator(const ir::AstNode *node, VReg completionType, VReg completionValue) const;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/function/generatorFunctionBuilder.cpp b/es2panda/compiler/function/generatorFunctionBuilder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a4d71b3fd2dac50aded1c33cabc31d89dac78a15
--- /dev/null
+++ b/es2panda/compiler/function/generatorFunctionBuilder.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "generatorFunctionBuilder.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/base/catchTable.h>
+#include <ir/base/scriptFunction.h>
+
+namespace panda::es2panda::compiler {
+
+void GeneratorFunctionBuilder::Prepare(const ir::ScriptFunction *node) const
+{
+    VReg callee = FunctionReg(node);
+
+    pg_->CreateGeneratorObj(node, callee);
+    pg_->StoreAccumulator(node, funcObj_);
+    pg_->SuspendGenerator(node, funcObj_);
+    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
+}
+
+void GeneratorFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
+{
+    const auto &labelSet = catchTable_->LabelSet();
+
+    pg_->SetLabel(node, labelSet.TryEnd());
+    pg_->SetLabel(node, labelSet.CatchBegin());
+    pg_->GeneratorComplete(node, funcObj_);
+    pg_->EmitThrow(node);
+    pg_->SetLabel(node, labelSet.CatchEnd());
+}
+
+void GeneratorFunctionBuilder::DirectReturn(const ir::AstNode *node) const
+{
+    pg_->GeneratorComplete(node, funcObj_);
+    pg_->CreateIterResultObject(node, true);
+    pg_->EmitReturn(node);
+}
+
+void GeneratorFunctionBuilder::ImplicitReturn(const ir::AstNode *node) const
+{
+    pg_->LoadConst(node, Constant::JS_UNDEFINED);
+    DirectReturn(node);
+}
+
+void GeneratorFunctionBuilder::Yield(const ir::AstNode *node)
+{
+    RegScope rs(pg_);
+    VReg completionType = pg_->AllocReg();
+    VReg completionValue = pg_->AllocReg();
+
+    pg_->CreateIterResultObject(node, false);
+    pg_->GeneratorYield(node, funcObj_);
+    SuspendResumeExecution(node, completionType, completionValue);
+
+    HandleCompletion(node, completionType, completionValue);
+}
+
+}  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/function/generatorFunctionBuilder.h b/es2panda/compiler/function/generatorFunctionBuilder.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1a12295654cff025fcd0754b8d1cd116074ecff
--- /dev/null
+++ b/es2panda/compiler/function/generatorFunctionBuilder.h
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_FUNCTION_GENERATOR_FUNCTION_BUILDER_H
+#define ES2PANDA_COMPILER_FUNCTION_GENERATOR_FUNCTION_BUILDER_H
+
+#include <ir/irnode.h>
+#include <compiler/function/functionBuilder.h>
+
+namespace panda::es2panda::ir {
+class YieldExpression;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::compiler {
+
+class PandaGen;
+
+enum class GeneratorState {
+    UNDEFINED = 0,
+    SUSPENDED_START,
+    SUSPENDED_YIELD,
+    EXECUTING,
+    COMPLETED,
+    AWAITING_RETURN,
+};
+
+class GeneratorFunctionBuilder : public FunctionBuilder {
+public:
+    explicit GeneratorFunctionBuilder(PandaGen *pg, CatchTable *catchTable) : FunctionBuilder(pg, catchTable) {}
+
+    ~GeneratorFunctionBuilder() override = default;
+    NO_COPY_SEMANTIC(GeneratorFunctionBuilder);
+    NO_MOVE_SEMANTIC(GeneratorFunctionBuilder);
+
+    void Prepare(const ir::ScriptFunction *node) const override;
+    void CleanUp(const ir::ScriptFunction *node) const override;
+
+    void DirectReturn(const ir::AstNode *node) const override;
+    void ImplicitReturn(const ir::AstNode *node) const override;
+
+    void Yield(const ir::AstNode *node) override;
+
+protected:
+    BuilderType BuilderKind() const override
+    {
+        return BuilderType::GENERATOR;
+    }
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/templates/formats.h.erb b/es2panda/compiler/templates/formats.h.erb
new file mode 100644
index 0000000000000000000000000000000000000000..71b9587a04096794352ef345cf9c22dcb1e39fec
--- /dev/null
+++ b/es2panda/compiler/templates/formats.h.erb
@@ -0,0 +1,83 @@
+% def get_format_name(mnemonic)
+%   return "#{mnemonic.gsub('.', '_').upcase}" + "_FORMATS"
+% end
+% def get_format_item_name(mnemonic, index)
+%   return "#{mnemonic.gsub('.', '_').upcase}" + "_FORMAT_ITEMS_" + index.to_s
+% end
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Autogenerated file -- DO NOT EDIT!
+
+#ifndef ES2PANDA_COMPILER_GEN_FORMATS_H
+#define ES2PANDA_COMPILER_GEN_FORMATS_H
+
+#include <ir/irnode.h>
+
+namespace panda::es2panda::compiler {
+
+% def get_operand_kind(op, insn)
+%   if op.reg?
+%     if op.src? and op.dst?
+%       return "OperandKind::SRC_DST_VREG"
+%     elsif op.src?
+%       return "OperandKind::SRC_VREG"
+%     elsif op.dst?
+%       return "OperandKind::DST_VREG"
+%     end
+%     return nil
+%   elsif op.imm?
+%     is_jump = insn.properties.include? 'jump'
+%     return is_jump ? "OperandKind::LABEL" : "OperandKind::IMM"
+%  elsif op.id?
+%    is_string_id = insn.properties.include? 'string_id'
+%    return is_string_id ? "OperandKind::STRING_ID" : "OperandKind::ID"
+%  else
+%    return nil
+%  end
+% end
+%
+% def make_format(fmt, insn)
+%   operands = fmt.operands.map {|op| "{#{get_operand_kind(op, insn)}, #{op.width}}"}
+%   return operands
+% end
+%
+% Panda::instructions.group_by(&:mnemonic).each do |mnemonic, group|
+% insn = group.first
+% formats = group.map {|i| make_format(i,insn) }
+% empty = false
+% formats.each.with_index do |fmt, index|
+%   if fmt.length != 0
+constexpr std::array<const FormatItem, <%= fmt.length %>> <%= get_format_item_name(mnemonic, index) %> = {{
+  <%= fmt.join(", ") %>
+}};
+%   else
+%     empty = true
+%   end
+% end
+%
+%   if empty
+constexpr std::array<const Format, 0> <%= get_format_name(mnemonic) %>  = {{}};
+%   else
+constexpr std::array<const Format, <%= formats.length %>> <%= get_format_name(mnemonic) %> = {{
+% format_items = (0..(formats.length - 1)).map {|index| "{" + get_format_item_name(mnemonic, index) + ".data(), " +  get_format_item_name(mnemonic, index) + ".size()}" }
+  <%= format_items.join(", ") %>
+%
+}};
+%   end
+% end
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/compiler/templates/isa.h.erb b/es2panda/compiler/templates/isa.h.erb
new file mode 100644
index 0000000000000000000000000000000000000000..49a5d5869c1eb651fd6c158ffd6743636b347afe
--- /dev/null
+++ b/es2panda/compiler/templates/isa.h.erb
@@ -0,0 +1,232 @@
+% def get_node_kind(mnemonic)
+%   return "#{mnemonic.gsub('.', '_').upcase}"
+% end
+%
+% def get_format_name(mnemonic)
+%   return "#{mnemonic.gsub('.', '_').upcase}" + "_FORMATS"
+% end
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Autogenerated file -- DO NOT EDIT!
+
+#ifndef ES2PANDA_COMPILER_GEN_IR_ISA_H
+#define ES2PANDA_COMPILER_GEN_IR_ISA_H
+
+#include <ir/irnode.h>
+#include <gen/formats.h>
+#include <assembly-ins.h>
+
+namespace panda::es2panda::compiler {
+
+class Label : public IRNode {
+public:
+    explicit Label(const ir::AstNode* node, std::string id) : IRNode(node), id_(std::move(id)) {}
+
+    static constexpr std::string_view PREFIX = "LABEL_";
+
+    Formats GetFormats() const override
+    {
+        return Span<const Format>(nullptr, nullptr);
+    }
+
+    const std::string &Id() const
+    {
+        return id_;
+    }
+
+    size_t Registers([[maybe_unused]] std::array<VReg*, MAX_REG_OPERAND>* regs) override
+    {
+        return 0;
+    }
+
+    size_t Registers([[maybe_unused]] std::array<const VReg*, MAX_REG_OPERAND>* regs) const override
+    {
+        return 0;
+    }
+
+    void Transform(pandasm::Ins *ins) const override
+    {
+        ins->opcode = pandasm::Opcode::INVALID;
+        ins->set_label = true;
+        ins->label = id_;
+    }
+
+private:
+    std::string id_;
+};
+
+% def insn2node(insn)
+%   mnemonic = insn.mnemonic.split('.')
+%   return mnemonic.map{|el| el == '64' ? 'Wide' : el.capitalize}.join()
+% end
+%
+% def is_VReg (name)
+%     if name ==  :v
+%        return true
+%     end
+% end
+%
+% def is_Acc(name)
+%    if name ==  :acc
+%        return true
+%     end
+% end
+%
+% def is_Imm(name)
+%    if name ==  :imm
+%        return true
+%     end
+% end
+%
+% def is_Id(name)
+%     if %i[method_id type_id field_id string_id stringId callsite_id literalarray_id].include?(name)
+%        return true
+%     end
+% end
+%
+% def get_operand_type(name, name_tmp, insn, map)
+%   if is_VReg (name_tmp)
+%     map['reg'].push("#{name}_")
+%     return 'VReg'
+%   elsif is_Imm(name_tmp)
+%     if insn.properties.include? 'jump'
+%       map['lbl'].push("#{name}_")
+%       return "Label*"
+%     end
+%     map['imm'].push("#{name}_")
+%     if insn.sig.include? 'imm:f64'
+%       return 'double'
+%     end
+%       return 'int64_t'
+%   elsif is_Id(name_tmp)
+%     map['str'].push("#{name}_")
+%     return 'util::StringView'
+%   else
+%     return nil
+%   end
+% end
+%
+% def get_operands(sig)
+%     return [] unless sig.include? ' '
+%     _, operands = sig.match(/(\S+) (.+)/).captures
+%     operands = operands.split(', ')
+%     end
+%
+% def get_ctor_args(insn)
+%     operands = get_operands(insn.sig)
+%     ops = Array.new
+%     ctor_args = Array.new
+%     op_map = Hash.new { |h, k| h[k] = [] }
+%     operands.map do |operand|
+%     operand_parts = operand.split(':')
+%       case operand_parts.size
+%       when 1
+%         name = operand_parts[0]
+%       when 2
+%         name, _ = operand_parts
+%       when 3
+%         name, _, _ = operand_parts
+%       else
+%         raise 'Unexpected operand string'
+%       end
+%
+%       name_tmp = name_tmp = name.to_s.gsub(/[0-9]/, '').to_sym;
+%
+%       if is_Id(name_tmp)
+%           name = "stringId"
+%       end
+%
+%       ops.push(name)
+%       type = get_operand_type(name, name_tmp, insn, op_map)
+%       ctor_args.push("#{type} #{name}")
+%     end
+%     return ops,ctor_args,op_map
+% end
+%
+% Panda::instructions.group_by(&:mnemonic).each do |mnemonic, group|
+% insn = group.first
+% node_kind = get_node_kind(mnemonic)
+% class_name = insn2node(insn)
+% base_class = "IRNode"
+% ops_list,ctor_arg_list,op_map = get_ctor_args(insn)
+% ctor_args = "const ir::AstNode* node" + (ctor_arg_list.length == 0 ? "" : ", ") + ctor_arg_list.map {|arg| "#{arg}"}.join(", ")
+% members = ctor_arg_list.map {|arg| "#{arg}_;"}.join("\n    ")
+% registers = op_map['reg'].map {|reg| "&#{reg}"}.join(", ")
+% ops = (ops_list.length == 0 ? "" : ", ") + ops_list.map { |op| "#{op}_(#{op})"}.join(", ")
+class <%= class_name %> : public <%= base_class %>
+{
+public:
+    explicit <%= class_name %>(<%= ctor_args %>) : <%= base_class %>(node)<%= ops %> {}
+
+    Formats GetFormats() const override {
+        return Span<const Format>(<%= get_format_name(insn.mnemonic) %>);
+    }
+
+    size_t Registers([[maybe_unused]] std::array<VReg*, MAX_REG_OPERAND>* regs) override
+    {
+% reg_cnt = 0
+% for reg in op_map['reg']
+        (*regs)[<%= reg_cnt %>] = &<%= reg %>;
+%   reg_cnt+=1;
+% end
+        return <%= reg_cnt %>;
+    }
+
+    size_t Registers([[maybe_unused]] std::array<const VReg*, MAX_REG_OPERAND>* regs) const override
+    {
+% reg_cnt = 0
+% for reg in op_map['reg']
+        (*regs)[<%= reg_cnt %>] = &<%= reg %>;
+%   reg_cnt+=1;
+% end
+        return <%= reg_cnt %>;
+    }
+
+    void Transform(pandasm::Ins* ins) const override {
+      ins->opcode = pandasm::Opcode::<%= node_kind %>;
+% if op_map['reg'].length != 0
+      ins->regs.reserve(<%= op_map['reg'].length %>);
+% end
+% if op_map['imm'].length != 0
+      ins->imms.reserve(<%= op_map['imm'].length %>);
+% end
+% if op_map['str'].length + op_map['lbl'].length != 0
+      ins->ids.reserve(<%= op_map['str'].length + op_map['lbl'].length %>);
+% end
+% for reg in op_map['reg']
+      ins->regs.emplace_back(<%= reg %>);
+% end
+% for imm in op_map['imm']
+      ins->imms.emplace_back(<%= imm %>);
+% end
+% for str in op_map['str']
+      ins->ids.emplace_back(<%= str %>.Mutf8());
+% end
+% for lbl in op_map['lbl']
+      ins->ids.emplace_back(<%= lbl %>->Id());
+% end
+    }
+
+% if ops_list.length != 0
+private:
+    <%= members %>
+% end
+};
+
+% end
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/es2panda.cpp b/es2panda/es2panda.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7bb412786ee1a9c11bb7555e706728235d66dcf1
--- /dev/null
+++ b/es2panda/es2panda.cpp
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "es2panda.h"
+
+#include <compiler/core/compileQueue.h>
+#include <compiler/core/compilerContext.h>
+#include <compiler/core/compilerImpl.h>
+#include <parser/parserImpl.h>
+#include <parser/program/program.h>
+
+#include <iostream>
+#include <thread>
+
+namespace panda::es2panda {
+// Compiler
+
+constexpr size_t DEFAULT_THREAD_COUNT = 2;
+
+Compiler::Compiler(ScriptExtension ext) : Compiler(ext, DEFAULT_THREAD_COUNT) {}
+
+Compiler::Compiler(ScriptExtension ext, size_t threadCount)
+    : parser_(new parser::ParserImpl(ext)), compiler_(new compiler::CompilerImpl(threadCount))
+{
+}
+
+Compiler::~Compiler()
+{
+    delete parser_;
+    delete compiler_;
+}
+
+panda::pandasm::Program *Compiler::Compile(const SourceFile &input, const CompilerOptions &options)
+{
+    /* TODO(dbatyai): pass string view */
+    std::string fname(input.fileName);
+    std::string src(input.source);
+
+    try {
+        auto ast = input.isModule ? parser_->ParseModule(fname, src) : parser_->ParseScript(fname, src);
+
+        if (options.dumpAst) {
+            std::cout << ast.Dump() << std::endl;
+        }
+
+        if (options.parseOnly) {
+            return nullptr;
+        }
+
+        auto *prog = compiler_->Compile(&ast, options);
+
+        return prog;
+    } catch (const class Error &e) {
+        error_ = e;
+        return nullptr;
+    }
+}
+
+void Compiler::DumpAsm(const panda::pandasm::Program *prog)
+{
+    compiler::CompilerImpl::DumpAsm(prog);
+}
+
+}  // namespace panda::es2panda
diff --git a/es2panda/es2panda.h b/es2panda/es2panda.h
new file mode 100644
index 0000000000000000000000000000000000000000..f68866c0caa52f0ecbf0a60cb7d8b18f122ddb6b
--- /dev/null
+++ b/es2panda/es2panda.h
@@ -0,0 +1,160 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PUBLIC_H
+#define ES2PANDA_PUBLIC_H
+
+#include <macros.h>
+
+#include <string>
+
+namespace panda::pandasm {
+struct Program;
+}  // namespace panda::pandasm
+
+namespace panda::es2panda {
+namespace parser {
+class ParserImpl;
+}  // namespace parser
+
+namespace compiler {
+class CompilerImpl;
+}  // namespace compiler
+
+enum class ScriptExtension {
+    JS,
+    TS,
+    AS,
+};
+
+struct SourceFile {
+    SourceFile(std::string_view fn, std::string_view s) : fileName(fn), source(s) {};
+    SourceFile(std::string_view fn, std::string_view s, bool m) : fileName(fn), source(s), isModule(m) {};
+
+    std::string_view fileName {};
+    std::string_view source {};
+    bool isModule {false};
+};
+
+struct CompilerOptions {
+    bool isDebug {false};
+    bool dumpAst {false};
+    bool dumpAsm {false};
+    bool dumpDebugInfo {false};
+    bool parseOnly {false};
+};
+
+enum class ErrorType {
+    GENERIC,
+    SYNTAX,
+    TYPE,
+};
+
+class Error : public std::exception {
+public:
+    Error() noexcept = default;
+    explicit Error(ErrorType type, std::string_view message) noexcept : type_(type), message_(message) {}
+    explicit Error(ErrorType type, std::string_view message, size_t line, size_t column) noexcept
+        : type_(type), message_(message), line_(line), col_(column)
+    {
+    }
+    ~Error() override = default;
+    DEFAULT_COPY_SEMANTIC(Error);
+    DEFAULT_MOVE_SEMANTIC(Error);
+
+    ErrorType Type() const noexcept
+    {
+        return type_;
+    }
+
+    const char *TypeString() const noexcept
+    {
+        switch (type_) {
+            case ErrorType::SYNTAX:
+                return "SyntaxError";
+            case ErrorType::TYPE:
+                return "TypeError";
+            default:
+                break;
+        }
+
+        return "Error";
+    }
+
+    const char *what() const noexcept override
+    {
+        return message_.c_str();
+    }
+
+    int ErrorCode() const noexcept
+    {
+        return errorCode_;
+    }
+
+    const std::string &Message() const noexcept
+    {
+        return message_;
+    }
+
+    size_t Line() const
+    {
+        return line_;
+    }
+
+    size_t Col() const
+    {
+        return col_;
+    }
+
+private:
+    ErrorType type_ {ErrorType::GENERIC};
+    std::string message_;
+    size_t line_ {};
+    size_t col_ {};
+    int errorCode_ {1};
+};
+
+class Compiler {
+public:
+    explicit Compiler(ScriptExtension ext);
+    explicit Compiler(ScriptExtension ext, size_t threadCount);
+    ~Compiler();
+    NO_COPY_SEMANTIC(Compiler);
+    NO_MOVE_SEMANTIC(Compiler);
+
+    panda::pandasm::Program *Compile(const SourceFile &input, const CompilerOptions &options);
+
+    inline panda::pandasm::Program *Compile(const SourceFile &input)
+    {
+        CompilerOptions options;
+
+        return Compile(input, options);
+    }
+
+    static void DumpAsm(const panda::pandasm::Program *prog);
+
+    const Error &GetError() const noexcept
+    {
+        return error_;
+    }
+
+private:
+    parser::ParserImpl *parser_;
+    compiler::CompilerImpl *compiler_;
+    Error error_;
+};
+}  // namespace panda::es2panda
+
+#endif
diff --git a/es2panda/ir/astDump.cpp b/es2panda/ir/astDump.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..acf37c7a810573771499467b9bee437e1459dd46
--- /dev/null
+++ b/es2panda/ir/astDump.cpp
@@ -0,0 +1,243 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "astDump.h"
+
+#include <ir/astNode.h>
+
+#include <cmath>
+#include <iostream>
+
+namespace panda::es2panda::ir {
+
+AstDumper::AstDumper(const BlockStatement *program, util::StringView sourceCode) : index_(sourceCode), indent_(0)
+{
+    SerializeObject(reinterpret_cast<const ir::AstNode *>(program));
+}
+
+void AstDumper::Add(std::initializer_list<AstDumper::Property> props)
+{
+    AddList<std::initializer_list<AstDumper::Property>>(props);
+}
+
+void AstDumper::Add(const AstDumper::Property &prop)
+{
+    Serialize(prop);
+}
+
+const char *AstDumper::ModifierToString(ModifierFlags flags)
+{
+    if (flags & ModifierFlags::PRIVATE) {
+        return "private";
+    }
+
+    if (flags & ModifierFlags::PROTECTED) {
+        return "protected";
+    }
+
+    if (flags & ModifierFlags::PUBLIC) {
+        return "public";
+    }
+
+    return nullptr;
+}
+
+const char *AstDumper::TypeOperatorToString(TSOperatorType operatorType)
+{
+    if (operatorType == TSOperatorType::KEYOF) {
+        return "keyof";
+    }
+
+    if (operatorType == TSOperatorType::READONLY) {
+        return "readonly";
+    }
+
+    if (operatorType == TSOperatorType::UNIQUE) {
+        return "unique";
+    }
+
+    return nullptr;
+}
+
+void AstDumper::Serialize(const AstDumper::Property &prop)
+{
+    SerializePropKey(prop.Key());
+    const auto &value = prop.Value();
+
+    if (std::holds_alternative<const char *>(value)) {
+        SerializeString(std::get<const char *>(value));
+    } else if (std::holds_alternative<util::StringView>(value)) {
+        SerializeString(std::get<util::StringView>(value));
+    } else if (std::holds_alternative<bool>(value)) {
+        SerializeBoolean(std::get<bool>(value));
+    } else if (std::holds_alternative<double>(value)) {
+        SerializeNumber(std::get<double>(value));
+    } else if (std::holds_alternative<const ir::AstNode *>(value)) {
+        SerializeObject(std::get<const ir::AstNode *>(value));
+    } else if (std::holds_alternative<std::vector<const ir::AstNode *>>(value)) {
+        SerializeArray(std::get<std::vector<const ir::AstNode *>>(value));
+    } else if (std::holds_alternative<lexer::TokenType>(value)) {
+        SerializeToken(std::get<lexer::TokenType>(value));
+    } else if (std::holds_alternative<std::initializer_list<Property>>(value)) {
+        SerializePropList(std::get<std::initializer_list<Property>>(value));
+    } else if (std::holds_alternative<Property::Constant>(value)) {
+        SerializeConstant(std::get<Property::Constant>(value));
+    }
+}
+
+void AstDumper::SerializeToken(lexer::TokenType token)
+{
+    ss_ << "\"" << lexer::TokenToString(token) << "\"";
+}
+
+void AstDumper::SerializePropKey(const char *str)
+{
+    ss_ << std::endl;
+    Indent();
+    SerializeString(str);
+    ss_ << ": ";
+}
+
+void AstDumper::SerializeString(const char *str)
+{
+    ss_ << "\"" << str << "\"";
+}
+
+void AstDumper::SerializeString(const util::StringView &str)
+{
+    ss_ << "\"" << str.Utf8() << "\"";
+}
+
+void AstDumper::SerializeNumber(size_t number)
+{
+    ss_ << number;
+}
+
+void AstDumper::SerializeNumber(double number)
+{
+    if (std::isinf(number)) {
+        ss_ << "\"Infinity\"";
+    } else {
+        ss_ << number;
+    }
+}
+
+void AstDumper::SerializeBoolean(bool boolean)
+{
+    ss_ << (boolean ? "true" : "false");
+}
+
+void AstDumper::SerializeConstant(Property::Constant constant)
+{
+    switch (constant) {
+        case Property::Constant::PROP_NULL: {
+            ss_ << "null";
+            break;
+        }
+        case Property::Constant::EMPTY_ARRAY: {
+            ss_ << "[]";
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+void AstDumper::SerializePropList(std::initializer_list<AstDumper::Property> props)
+{
+    Wrap([this, &props]() -> void {
+        for (const auto *it = props.begin(); it != props.end(); ++it) {
+            Serialize(*it);
+            if (std::next(it) != props.end()) {
+                ss_ << ',';
+            }
+        }
+    });
+}
+
+void AstDumper::SerializeArray(std::vector<const ir::AstNode *> array)
+{
+    Wrap(
+        [this, &array]() -> void {
+            for (auto it = array.begin(); it != array.end(); ++it) {
+                ss_ << std::endl;
+                Indent();
+
+                SerializeObject(*it);
+
+                if (std::next(it) != array.end()) {
+                    ss_ << ',';
+                }
+            }
+        },
+        '[', ']');
+}
+
+void AstDumper::SerializeObject(const ir::AstNode *object)
+{
+    Wrap([this, object]() -> void {
+        object->Dump(this);
+        SerializeLoc(object->Range());
+    });
+}
+
+void AstDumper::Wrap(const WrapperCb &cb, char delimStart, char delimEnd)
+{
+    ss_ << delimStart;
+    indent_++;
+
+    cb();
+    ss_ << std::endl;
+    indent_--;
+    Indent();
+    ss_ << delimEnd;
+}
+
+void AstDumper::SerializeLoc(const lexer::SourceRange &loc)
+{
+    ss_ << ',';
+    SerializePropKey("loc");
+
+    Wrap([this, &loc]() -> void {
+        SerializePropKey("start");
+        SerializeSourcePosition(loc.start);
+        ss_ << ',';
+        SerializePropKey("end");
+        SerializeSourcePosition(loc.end);
+    });
+}
+
+void AstDumper::SerializeSourcePosition(const lexer::SourcePosition &pos)
+{
+    lexer::SourceLocation loc = index_.GetLocation(pos);
+
+    Wrap([this, &loc]() -> void {
+        SerializePropKey("line");
+        SerializeNumber(loc.line);
+        ss_ << ',';
+        SerializePropKey("column");
+        SerializeNumber(loc.col);
+    });
+}
+
+void AstDumper::Indent()
+{
+    for (int32_t i = 0; i < indent_; i++) {
+        ss_ << "  ";
+    }
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/astDump.h b/es2panda/ir/astDump.h
new file mode 100644
index 0000000000000000000000000000000000000000..ece0397babc56562c32c74e1cf5f62297cf41b65
--- /dev/null
+++ b/es2panda/ir/astDump.h
@@ -0,0 +1,206 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_ASTDUMP_H
+#define ES2PANDA_IR_ASTDUMP_H
+
+#include <ir/astNode.h>
+#include <lexer/token/sourceLocation.h>
+#include <lexer/token/tokenType.h>
+#include <util/ustring.h>
+
+#include <sstream>
+#include <variant>
+
+namespace panda::es2panda::ir {
+
+class AstDumper {
+public:
+    class Nullable {
+    public:
+        explicit Nullable(const ir::AstNode *node) : node_(node) {}
+
+        const ir::AstNode *Node() const
+        {
+            return node_;
+        }
+
+    private:
+        const ir::AstNode *node_;
+    };
+
+    class Optional {
+    public:
+        using Val = std::variant<const char *, const ir::AstNode *, bool>;
+        explicit Optional(const ir::AstNode *node) : value_(node) {}
+        explicit Optional(const char *string) : value_(const_cast<char *>(string)) {}
+        explicit Optional(bool boolean) : value_(boolean) {}
+
+        const Val &Value() const
+        {
+            return value_;
+        }
+
+    private:
+        Val value_;
+    };
+
+    class Property {
+    public:
+        class Ignore {
+        public:
+            Ignore() = default;
+        };
+
+        enum class Constant {
+            PROP_NULL,
+            EMPTY_ARRAY,
+        };
+
+        using Val =
+            std::variant<const char *, lexer::TokenType, std::initializer_list<Property>, util::StringView, bool,
+                         double, const ir::AstNode *, std::vector<const ir::AstNode *>, Constant, Nullable, Ignore>;
+
+        Property(const char *key, const char *string) : key_(key), value_(string) {}
+        Property(const char *key, util::StringView str) : key_(key), value_(str) {}
+        Property(const char *key, bool boolean) : key_(key), value_(boolean) {}
+        Property(const char *key, double number) : key_(key), value_(number) {}
+        Property(const char *key, lexer::TokenType token) : key_(key), value_(token) {}
+        Property(const char *key, std::initializer_list<Property> props) : key_(key), value_(props) {}
+        Property(const char *key, const ir::AstNode *node) : key_(key), value_(const_cast<ir::AstNode *>(node)) {}
+
+        Property(const char *key, Constant constant) : key_(key), value_(constant) {}
+        Property(const char *key, Nullable nullable) : key_(key)
+        {
+            if (nullable.Node()) {
+                value_ = nullable.Node();
+            } else {
+                value_ = Property::Constant::PROP_NULL;
+            }
+        }
+
+        Property(const char *key, Optional optional) : key_(key)
+        {
+            const auto &value = optional.Value();
+            if (std::holds_alternative<const ir::AstNode *>(value) && std::get<const ir::AstNode *>(value)) {
+                value_ = std::get<const ir::AstNode *>(value);
+                return;
+            }
+
+            if (std::holds_alternative<const char *>(value) && std::get<const char *>(value)) {
+                value_ = std::get<const char *>(value);
+                return;
+            }
+
+            if (std::holds_alternative<bool>(value) && std::get<bool>(value)) {
+                value_ = std::get<bool>(value);
+                return;
+            }
+
+            value_ = Ignore();
+        }
+
+        template <typename T>
+        Property(const char *key, const ArenaVector<T> &array) : key_(key)
+        {
+            if (array.empty()) {
+                value_ = Constant::EMPTY_ARRAY;
+                return;
+            }
+
+            std::vector<const ir::AstNode *> nodes;
+            nodes.reserve(array.size());
+
+            for (auto &it : array) {
+                nodes.push_back(it);
+            }
+
+            value_ = std::move(nodes);
+        }
+
+        const char *Key() const
+        {
+            return key_;
+        }
+
+        const Val &Value() const
+        {
+            return value_;
+        }
+
+    private:
+        const char *key_;
+        Val value_ {false};
+    };
+
+    explicit AstDumper(const BlockStatement *program, util::StringView sourceCode);
+
+    void Add(std::initializer_list<Property> props);
+    void Add(const AstDumper::Property &prop);
+
+    static const char *ModifierToString(ModifierFlags flags);
+    static const char *TypeOperatorToString(TSOperatorType operatorType);
+
+    std::string Str() const
+    {
+        return ss_.str();
+    }
+
+private:
+    using WrapperCb = std::function<void()>;
+
+    template <typename T>
+    void AddList(T props)
+    {
+        for (auto it = props.begin(); it != props.end();) {
+            Serialize(*it);
+
+            do {
+                if (++it == props.end()) {
+                    return;
+                }
+            } while (std::holds_alternative<Property::Ignore>((*it).Value()));
+
+            ss_ << ',';
+        }
+    }
+
+    void Indent();
+
+    void Serialize(const AstDumper::Property &prop);
+    void SerializePropKey(const char *str);
+    void SerializeString(const char *str);
+    void SerializeString(const util::StringView &str);
+    void SerializeNumber(size_t number);
+    void SerializeNumber(double number);
+    void SerializeBoolean(bool boolean);
+    void SerializeObject(const ir::AstNode *object);
+    void SerializeToken(lexer::TokenType token);
+    void SerializePropList(std::initializer_list<AstDumper::Property> props);
+    void SerializeConstant(Property::Constant constant);
+    void Wrap(const WrapperCb &cb, char delimStart = '{', char delimEnd = '}');
+
+    void SerializeLoc(const lexer::SourceRange &loc);
+    void SerializeSourcePosition(const lexer::SourcePosition &pos);
+
+    void SerializeArray(std::vector<const ir::AstNode *> array);
+
+    lexer::LineIndex index_;
+    std::stringstream ss_;
+    int32_t indent_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif  // ASTDUMP_H
diff --git a/es2panda/ir/astNode.h b/es2panda/ir/astNode.h
new file mode 100644
index 0000000000000000000000000000000000000000..31f55dacba36f5e7825847f95743c43a0a62c784
--- /dev/null
+++ b/es2panda/ir/astNode.h
@@ -0,0 +1,277 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_ASTNODE_H
+#define ES2PANDA_IR_ASTNODE_H
+
+#include <ir/astNodeMapping.h>
+#include <lexer/token/sourceLocation.h>
+#include <util/enumbitops.h>
+
+#include <functional>
+#include <macros.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class AstNode;
+
+using NodeTraverser = std::function<void(AstNode *)>;
+
+enum class AstNodeType {
+#define DECLARE_NODE_TYPES(nodeType, className) nodeType,
+    AST_NODE_MAPPING(DECLARE_NODE_TYPES)
+#undef DECLARE_NODE_TYPES
+#define DECLARE_NODE_TYPES(nodeType1, nodeType2, baseClass, reinterpretClass) nodeType1, nodeType2,
+        AST_NODE_REINTERPRET_MAPPING(DECLARE_NODE_TYPES)
+#undef DECLARE_NODE_TYPES
+};
+
+enum class AstNodeFlags {
+    NO_OPTS = 0,
+    STRICT = (1U << 0U),
+    PARAMETER = (1U << 1U),
+};
+
+DEFINE_BITOPS(AstNodeFlags)
+
+enum class ModifierFlags {
+    NONE = 0,
+    STATIC = 1 << 0,
+    ASYNC = 1 << 1,
+    PUBLIC = 1 << 2,
+    PROTECTED = 1 << 3,
+    PRIVATE = 1 << 4,
+    DECLARE = 1 << 5,
+    READONLY = 1 << 6,
+    OPTIONAL = 1 << 7,
+    DEFINITE = 1 << 8,
+    ABSTRACT = 1 << 9,
+    ACCESS = PUBLIC | PROTECTED | PRIVATE,
+    ALL = STATIC | ASYNC | ACCESS | DECLARE | READONLY | ABSTRACT,
+    ALLOWED_IN_CTOR_PARAMETER = ACCESS | READONLY,
+};
+
+DEFINE_BITOPS(ModifierFlags)
+
+enum class ScriptFunctionFlags {
+    NONE = 0,
+    GENERATOR = 1 << 0,
+    ASYNC = 1 << 1,
+    ARROW = 1 << 2,
+    EXPRESSION = 1 << 3,
+    OVERLOAD = 1 << 4,
+    CONSTRUCTOR = 1 << 5,
+    METHOD = 1 << 6
+};
+
+DEFINE_BITOPS(ScriptFunctionFlags)
+
+enum class TSOperatorType { READONLY, KEYOF, UNIQUE };
+enum class MappedOption { NO_OPTS, PLUS, MINUS };
+
+// Predefinitions
+class AstDumper;
+class Expression;
+class Statement;
+
+#define DECLARE_CLASSES(nodeType, className) class className;
+AST_NODE_MAPPING(DECLARE_CLASSES)
+#undef DECLARE_CLASSES
+
+#define DECLARE_CLASSES(nodeType1, nodeType2, baseClass, reinterpretClass) class baseClass;
+AST_NODE_REINTERPRET_MAPPING(DECLARE_CLASSES)
+#undef DECLARE_CLASSES
+
+class AstNode {
+public:
+    explicit AstNode(AstNodeType type) : type_(type) {};
+    virtual ~AstNode() = default;
+    NO_COPY_SEMANTIC(AstNode);
+    NO_MOVE_SEMANTIC(AstNode);
+
+    bool IsProgram() const
+    {
+        return parent_ == nullptr;
+    }
+
+#define DECLARE_IS_CHECKS(nodeType, className) \
+    bool Is##className() const                 \
+    {                                          \
+        return type_ == AstNodeType::nodeType; \
+    }
+    AST_NODE_MAPPING(DECLARE_IS_CHECKS)
+#undef DECLARE_IS_CHECKS
+
+#define DECLARE_IS_CHECKS(nodeType1, nodeType2, baseClass, reinterpretClass) \
+    bool Is##baseClass() const                                               \
+    {                                                                        \
+        return type_ == AstNodeType::nodeType1;                              \
+    }                                                                        \
+    bool Is##reinterpretClass() const                                        \
+    {                                                                        \
+        return type_ == AstNodeType::nodeType2;                              \
+    }
+    AST_NODE_REINTERPRET_MAPPING(DECLARE_IS_CHECKS)
+#undef DECLARE_IS_CHECKS
+
+    virtual bool IsStatement() const
+    {
+        return false;
+    }
+
+    virtual bool IsExpression() const
+    {
+        return false;
+    }
+
+#define DECLARE_AS_CASTS(nodeType, className)             \
+    className *As##className()                            \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<className *>(this);       \
+    }                                                     \
+    const className *As##className() const                \
+    {                                                     \
+        ASSERT(Is##className());                          \
+        return reinterpret_cast<const className *>(this); \
+    }
+    AST_NODE_MAPPING(DECLARE_AS_CASTS)
+#undef DECLARE_AS_CASTS
+
+#define DECLARE_AS_CASTS(nodeType1, nodeType2, baseClass, reinterpretClass) \
+    baseClass *As##baseClass()                                              \
+    {                                                                       \
+        ASSERT(Is##baseClass());                                            \
+        return reinterpret_cast<baseClass *>(this);                         \
+    }                                                                       \
+    baseClass *As##reinterpretClass()                                       \
+    {                                                                       \
+        ASSERT(Is##reinterpretClass());                                     \
+        return reinterpret_cast<baseClass *>(this);                         \
+    }                                                                       \
+    const baseClass *As##baseClass() const                                  \
+    {                                                                       \
+        ASSERT(Is##baseClass());                                            \
+        return reinterpret_cast<const baseClass *>(this);                   \
+    }                                                                       \
+    const baseClass *As##reinterpretClass() const                           \
+    {                                                                       \
+        ASSERT(Is##reinterpretClass());                                     \
+        return reinterpret_cast<const baseClass *>(this);                   \
+    }
+    AST_NODE_REINTERPRET_MAPPING(DECLARE_AS_CASTS)
+#undef DECLARE_AS_CASTS
+
+    Expression *AsExpression()
+    {
+        ASSERT(IsExpression());
+        return reinterpret_cast<Expression *>(this);
+    }
+
+    const Expression *AsExpression() const
+    {
+        ASSERT(IsExpression());
+        return reinterpret_cast<const Expression *>(this);
+    }
+
+    Statement *AsStatement()
+    {
+        ASSERT(IsStatement());
+        return reinterpret_cast<Statement *>(this);
+    }
+
+    const Statement *AsStatement() const
+    {
+        ASSERT(IsStatement());
+        return reinterpret_cast<const Statement *>(this);
+    }
+
+    void SetRange(const lexer::SourceRange &loc)
+    {
+        range_ = loc;
+    }
+
+    void SetStart(const lexer::SourcePosition &start)
+    {
+        range_.start = start;
+    }
+
+    void SetEnd(const lexer::SourcePosition &end)
+    {
+        range_.end = end;
+    }
+
+    const lexer::SourcePosition &Start() const
+    {
+        return range_.start;
+    }
+
+    const lexer::SourcePosition &End() const
+    {
+        return range_.end;
+    }
+
+    const lexer::SourceRange &Range() const
+    {
+        return range_;
+    }
+
+    AstNodeType Type() const
+    {
+        return type_;
+    }
+
+    const AstNode *Parent()
+    {
+        return parent_;
+    }
+
+    const AstNode *Parent() const
+    {
+        return parent_;
+    }
+
+    void SetParent(const AstNode *parent)
+    {
+        parent_ = parent;
+    }
+
+    virtual void Iterate(const NodeTraverser &cb) const = 0;
+    virtual void Dump(ir::AstDumper *dumper) const = 0;
+    virtual void Compile([[maybe_unused]] compiler::PandaGen *pg) const = 0;
+    virtual checker::Type *Check([[maybe_unused]] checker::Checker *checker) const = 0;
+
+protected:
+    void SetType(AstNodeType type)
+    {
+        type_ = type;
+    }
+
+    const AstNode *parent_ {};
+    lexer::SourceRange range_ {};
+    AstNodeType type_;
+};
+
+}  // namespace panda::es2panda::ir
+#endif
diff --git a/es2panda/ir/astNodeMapping.h b/es2panda/ir/astNodeMapping.h
new file mode 100644
index 0000000000000000000000000000000000000000..decf76bb9d160fc0b8aac063bdfbd5235ff54ac3
--- /dev/null
+++ b/es2panda/ir/astNodeMapping.h
@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_AST_NODE_MAPPING_H
+#define ES2PANDA_IR_AST_NODE_MAPPING_H
+
+#define AST_NODE_MAPPING(_)                                          \
+    _(ARROW_FUNCTION_EXPRESSION, ArrowFunctionExpression)            \
+    _(AWAIT_EXPRESSION, AwaitExpression)                             \
+    _(BIGINT_LITERAL, BigIntLiteral)                                 \
+    _(BINARY_EXPRESSION, BinaryExpression)                           \
+    _(BLOCK_STATEMENT, BlockStatement)                               \
+    _(BOOLEAN_LITERAL, BooleanLiteral)                               \
+    _(BREAK_STATEMENT, BreakStatement)                               \
+    _(CALL_EXPRESSION, CallExpression)                               \
+    _(CATCH_CLAUSE, CatchClause)                                     \
+    _(CHAIN_EXPRESSION, ChainExpression)                             \
+    _(CLASS_DEFINITION, ClassDefinition)                             \
+    _(CLASS_DECLARATION, ClassDeclaration)                           \
+    _(CLASS_EXPRESSION, ClassExpression)                             \
+    _(CLASS_PROPERTY, ClassProperty)                                 \
+    _(CONDITIONAL_EXPRESSION, ConditionalExpression)                 \
+    _(CONTINUE_STATEMENT, ContinueStatement)                         \
+    _(DEBUGGER_STATEMENT, DebuggerStatement)                         \
+    _(DECORATOR, Decorator)                                          \
+    _(DO_WHILE_STATEMENT, DoWhileStatement)                          \
+    _(EMPTY_STATEMENT, EmptyStatement)                               \
+    _(EXPORT_ALL_DECLARATION, ExportAllDeclaration)                  \
+    _(EXPORT_DEFAULT_DECLARATION, ExportDefaultDeclaration)          \
+    _(EXPORT_NAMED_DECLARATION, ExportNamedDeclaration)              \
+    _(EXPORT_SPECIFIER, ExportSpecifier)                             \
+    _(EXPRESSION_STATEMENT, ExpressionStatement)                     \
+    _(FOR_IN_STATEMENT, ForInStatement)                              \
+    _(FOR_OF_STATEMENT, ForOfStatement)                              \
+    _(FOR_UPDATE_STATEMENT, ForUpdateStatement)                      \
+    _(FUNCTION_DECLARATION, FunctionDeclaration)                     \
+    _(FUNCTION_EXPRESSION, FunctionExpression)                       \
+    _(IDENTIFIER, Identifier)                                        \
+    _(IF_STATEMENT, IfStatement)                                     \
+    _(IMPORT_DECLARATION, ImportDeclaration)                         \
+    _(IMPORT_EXPRESSION, ImportExpression)                           \
+    _(IMPORT_DEFAULT_SPECIFIER, ImportDefaultSpecifier)              \
+    _(IMPORT_NAMESPACE_SPECIFIER, ImportNamespaceSpecifier)          \
+    _(IMPORT_SPECIFIER, ImportSpecifier)                             \
+    _(LABELLED_STATEMENT, LabelledStatement)                         \
+    _(MEMBER_EXPRESSION, MemberExpression)                           \
+    _(META_PROPERTY_EXPRESSION, MetaProperty)                        \
+    _(METHOD_DEFINITION, MethodDefinition)                           \
+    _(NEW_EXPRESSION, NewExpression)                                 \
+    _(NULL_LITERAL, NullLiteral)                                     \
+    _(NUMBER_LITERAL, NumberLiteral)                                 \
+    _(OMITTED_EXPRESSION, OmittedExpression)                         \
+    _(PROPERTY, Property)                                            \
+    _(REGEXP_LITERAL, RegExpLiteral)                                 \
+    _(RETURN_STATEMENT, ReturnStatement)                             \
+    _(SCRIPT_FUNCTION, ScriptFunction)                               \
+    _(SEQUENCE_EXPRESSION, SequenceExpression)                       \
+    _(STRING_LITERAL, StringLiteral)                                 \
+    _(SUPER_EXPRESSION, SuperExpression)                             \
+    _(SWITCH_CASE_STATEMENT, SwitchCaseStatement)                    \
+    _(SWITCH_STATEMENT, SwitchStatement)                             \
+    _(TS_ENUM_DECLARATION, TSEnumDeclaration)                        \
+    _(TS_ENUM_MEMBER, TSEnumMember)                                  \
+    _(TS_EXTERNAL_MODULE_REFERENCE, TSExternalModuleReference)       \
+    _(TS_PRIVATE_IDENTIFIER, TSPrivateIdentifier)                    \
+    _(TS_NUMBER_KEYWORD, TSNumberKeyword)                            \
+    _(TS_ANY_KEYWORD, TSAnyKeyword)                                  \
+    _(TS_STRING_KEYWORD, TSStringKeyword)                            \
+    _(TS_BOOLEAN_KEYWORD, TSBooleanKeyword)                          \
+    _(TS_VOID_KEYWORD, TSVoidKeyword)                                \
+    _(TS_UNDEFINED_KEYWORD, TSUndefinedKeyword)                      \
+    _(TS_UNKNOWN_KEYWORD, TSUnknownKeyword)                          \
+    _(TS_OBJECT_KEYWORD, TSObjectKeyword)                            \
+    _(TS_BIGINT_KEYWORD, TSBigintKeyword)                            \
+    _(TS_NEVER_KEYWORD, TSNeverKeyword)                              \
+    _(TS_NON_NULL_EXPRESSION, TSNonNullExpression)                   \
+    _(TS_NULL_KEYWORD, TSNullKeyword)                                \
+    _(TS_ARRAY_TYPE, TSArrayType)                                    \
+    _(TS_UNION_TYPE, TSUnionType)                                    \
+    _(TS_TYPE_LITERAL, TSTypeLiteral)                                \
+    _(TS_PROPERTY_SIGNATURE, TSPropertySignature)                    \
+    _(TS_METHOD_SIGNATURE, TSMethodSignature)                        \
+    _(TS_SIGNATURE_DECLARATION, TSSignatureDeclaration)              \
+    _(TS_PARENT_TYPE, TSParenthesizedType)                           \
+    _(TS_LITERAL_TYPE, TSLiteralType)                                \
+    _(TS_INFER_TYPE, TSInferType)                                    \
+    _(TS_CONDITIONAL_TYPE, TSConditionalType)                        \
+    _(TS_IMPORT_TYPE, TSImportType)                                  \
+    _(TS_INTERSECTION_TYPE, TSIntersectionType)                      \
+    _(TS_MAPPED_TYPE, TSMappedType)                                  \
+    _(TS_MODULE_BLOCK, TSModuleBlock)                                \
+    _(TS_THIS_TYPE, TSThisType)                                      \
+    _(TS_TYPE_OPERATOR, TSTypeOperator)                              \
+    _(TS_TYPE_PARAMETER, TSTypeParameter)                            \
+    _(TS_TYPE_PARAMETER_DECLARATION, TSTypeParameterDeclaration)     \
+    _(TS_TYPE_PARAMETER_INSTANTIATION, TSTypeParameterInstantiation) \
+    _(TS_TYPE_PREDICATE, TSTypePredicate)                            \
+    _(TS_PARAMETER_PROPERTY, TSParameterProperty)                    \
+    _(TS_MODULE_DECLARATION, TSModuleDeclaration)                    \
+    _(TS_IMPORT_EQUALS_DECLARATION, TSImportEqualsDeclaration)       \
+    _(TS_FUNCTION_TYPE, TSFunctionType)                              \
+    _(TS_CONSTRUCTOR_TYPE, TSConstructorType)                        \
+    _(TS_TYPE_ALIAS_DECLARATION, TSTypeAliasDeclaration)             \
+    _(TS_TYPE_REFERENCE, TSTypeReference)                            \
+    _(TS_QUALIFIED_NAME, TSQualifiedName)                            \
+    _(TS_INDEXED_ACCESS_TYPE, TSIndexedAccessType)                   \
+    _(TS_INTERFACE_DECLARATION, TSInterfaceDeclaration)              \
+    _(TS_INTERFACE_BODY, TSInterfaceBody)                            \
+    _(TS_INTERFACE_HERITAGE, TSInterfaceHeritage)                    \
+    _(TS_TUPLE_TYPE, TSTupleType)                                    \
+    _(TS_NAMED_TUPLE_MEMBER, TSNamedTupleMember)                     \
+    _(TS_INDEX_SIGNATURE, TSIndexSignature)                          \
+    _(TS_TYPE_QUERY, TSTypeQuery)                                    \
+    _(TS_AS_EXPRESSION, TSAsExpression)                              \
+    _(TS_TYPE_ASSERTION, TSTypeAssertion)                            \
+    _(TAGGED_TEMPLATE_EXPRESSION, TaggedTemplateExpression)          \
+    _(TAGGED_LITERAL, TaggedLiteral)                                 \
+    _(TEMPLATE_ELEMENT, TemplateElement)                             \
+    _(TEMPLATE_LITERAL, TemplateLiteral)                             \
+    _(THIS_EXPRESSION, ThisExpression)                               \
+    _(THROW_STATEMENT, ThrowStatement)                               \
+    _(TRY_STATEMENT, TryStatement)                                   \
+    _(UNARY_EXPRESSION, UnaryExpression)                             \
+    _(UPDATE_EXPRESSION, UpdateExpression)                           \
+    _(VARIABLE_DECLARATION, VariableDeclaration)                     \
+    _(VARIABLE_DECLARATOR, VariableDeclarator)                       \
+    _(WHILE_STATEMENT, WhileStatement)                               \
+    _(WITH_STATEMENT, WithStatement)                                 \
+    _(YIELD_EXPRESSION, YieldExpression)
+
+#define AST_NODE_REINTERPRET_MAPPING(_)                                                   \
+    _(ARRAY_EXPRESSION, ARRAY_PATTERN, ArrayExpression, ArrayPattern)                     \
+    _(ASSIGNMENT_EXPRESSION, ASSIGNMENT_PATTERN, AssignmentExpression, AssignmentPattern) \
+    _(OBJECT_EXPRESSION, OBJECT_PATTERN, ObjectExpression, ObjectPattern)                 \
+    _(SPREAD_ELEMENT, REST_ELEMENT, SpreadElement, RestElement)
+
+#endif
diff --git a/es2panda/ir/base/catchClause.cpp b/es2panda/ir/base/catchClause.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..59a91d30603f09bcfcb818a268254a090a5f9554
--- /dev/null
+++ b/es2panda/ir/base/catchClause.cpp
@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "catchClause.h"
+
+#include <binder/scope.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/base/lreference.h>
+#include <typescript/checker.h>
+#include <typescript/types/type.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/statements/blockStatement.h>
+
+namespace panda::es2panda::ir {
+
+void CatchClause::Iterate(const NodeTraverser &cb) const
+{
+    if (param_) {
+        cb(param_);
+    }
+
+    cb(body_);
+}
+
+void CatchClause::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "CatchClause"}, {"body", body_}, {"param", AstDumper::Nullable(param_)}});
+}
+
+void CatchClause::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LocalRegScope lrs(pg, scope_->ParamScope());
+
+    if (param_) {
+        auto lref = compiler::LReference::CreateLRef(pg, param_, true);
+        lref.SetValue();
+    }
+
+    ASSERT(scope_ == body_->Scope());
+    body_->Compile(pg);
+}
+
+checker::Type *CatchClause::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    const ir::Expression *typeAnnotation = nullptr;
+
+    if (param_->IsIdentifier()) {
+        typeAnnotation = param_->AsIdentifier()->TypeAnnotation();
+    } else if (param_->IsArrayPattern()) {
+        typeAnnotation = param_->AsArrayPattern()->TypeAnnotation();
+    } else {
+        ASSERT(param_->IsObjectPattern());
+        typeAnnotation = param_->AsObjectPattern()->TypeAnnotation();
+    }
+
+    if (typeAnnotation) {
+        checker::Type *catchParamType = typeAnnotation->Check(checker);
+
+        if (!catchParamType->HasTypeFlag(checker::TypeFlag::ANY_OR_UNKNOWN)) {
+            checker->ThrowTypeError("Catch clause variable type annotation must be 'any' or 'unknown' if specified",
+                                    Start());
+        }
+    }
+
+    body_->Check(checker);
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/catchClause.h b/es2panda/ir/base/catchClause.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce770405954744adbd76ea3da644eb8245b1b901
--- /dev/null
+++ b/es2panda/ir/base/catchClause.h
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_BASE_CATCH_CLAUSE_H
+#define ES2PANDA_IR_BASE_CATCH_CLAUSE_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class CatchScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class BlockStatement;
+class Expression;
+
+class CatchClause : public Statement {
+public:
+    explicit CatchClause(binder::CatchScope *scope, Expression *param, BlockStatement *body)
+        : Statement(AstNodeType::CATCH_CLAUSE), scope_(scope), param_(param), body_(body)
+    {
+    }
+
+    Expression *Param()
+    {
+        return param_;
+    }
+
+    const Expression *Param() const
+    {
+        return param_;
+    }
+
+    BlockStatement *Body()
+    {
+        return body_;
+    }
+
+    const BlockStatement *Body() const
+    {
+        return body_;
+    }
+
+    binder::CatchScope *Scope() const
+    {
+        return scope_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    binder::CatchScope *scope_;
+    Expression *param_;
+    BlockStatement *body_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/classDefinition.cpp b/es2panda/ir/base/classDefinition.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd18a40d3425b32ea918bd40b81e76f83b0d36a3
--- /dev/null
+++ b/es2panda/ir/base/classDefinition.cpp
@@ -0,0 +1,287 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "classDefinition.h"
+
+#include <util/helpers.h>
+#include <binder/scope.h>
+#include <compiler/base/literals.h>
+#include <compiler/base/lreference.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/methodDefinition.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/expression.h>
+#include <ir/expressions/functionExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/nullLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/literals/taggedLiteral.h>
+#include <ir/ts/tsClassImplements.h>
+#include <ir/ts/tsIndexSignature.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+
+namespace panda::es2panda::ir {
+
+const FunctionExpression *ClassDefinition::Ctor() const
+{
+    ASSERT(ctor_ != nullptr);
+    return ctor_->Value();
+}
+
+void ClassDefinition::Iterate(const NodeTraverser &cb) const
+{
+    if (ident_) {
+        cb(ident_);
+    }
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    if (superClass_) {
+        cb(superClass_);
+    }
+
+    if (superTypeParams_) {
+        cb(superTypeParams_);
+    }
+
+    for (auto *it : implements_) {
+        cb(it);
+    }
+
+    cb(ctor_);
+
+    for (auto *it : body_) {
+        cb(it);
+    }
+
+    for (auto *it : indexSignatures_) {
+        cb(it);
+    }
+}
+
+void ClassDefinition::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"id", AstDumper::Nullable(ident_)},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"superClass", AstDumper::Nullable(superClass_)},
+                 {"superTypeParameters", AstDumper::Optional(superTypeParams_)},
+                 {"implements", implements_},
+                 {"constructor", ctor_},
+                 {"body", body_},
+                 {"indexSignatures", indexSignatures_}});
+}
+
+compiler::VReg ClassDefinition::CompileHeritageClause(compiler::PandaGen *pg) const
+{
+    compiler::VReg baseReg = pg->AllocReg();
+
+    if (superClass_) {
+        superClass_->Compile(pg);
+    } else {
+        pg->LoadConst(this, compiler::Constant::JS_HOLE);
+    }
+
+    pg->StoreAccumulator(this, baseReg);
+    return baseReg;
+}
+
+void ClassDefinition::InitializeClassName(compiler::PandaGen *pg) const
+{
+    if (!ident_) {
+        return;
+    }
+
+    compiler::LReference lref = compiler::LReference::CreateLRef(pg, ident_, true);
+    lref.SetValue();
+}
+
+// NOLINTNEXTLINE(google-runtime-references)
+int32_t ClassDefinition::CreateClassStaticProperties(compiler::PandaGen *pg, util::BitSet &compiled) const
+{
+    auto *buf = pg->NewLiteralBuffer();
+    compiler::LiteralBuffer staticBuf(pg->Allocator());
+    bool seenComputed = false;
+    std::unordered_map<util::StringView, size_t> propNameMap;
+    std::unordered_map<util::StringView, size_t> staticPropNameMap;
+
+    const auto &properties = body_;
+
+    for (size_t i = 0; i < properties.size(); i++) {
+        if (!properties[i]->IsMethodDefinition()) {
+            continue;
+        }
+        const ir::MethodDefinition *prop = properties[i]->AsMethodDefinition();
+
+        if (!util::Helpers::IsConstantPropertyKey(prop->Key(), prop->Computed()) ||
+            (prop->Computed() && util::Helpers::IsSpecialPropertyKey(prop->Key()))) {
+            seenComputed = true;
+            continue;
+        }
+
+        util::StringView name = util::Helpers::LiteralToPropName(prop->Key());
+        compiler::LiteralBuffer *literalBuf = prop->IsStatic() ? &staticBuf : buf;
+        auto &nameMap = prop->IsStatic() ? staticPropNameMap : propNameMap;
+
+        size_t bufferPos = literalBuf->Literals().size();
+        auto res = nameMap.insert({name, bufferPos});
+        if (res.second) {
+            if (seenComputed) {
+                break;
+            }
+
+            literalBuf->Add(pg->Allocator()->New<StringLiteral>(name));
+            literalBuf->Add(nullptr);
+        } else {
+            bufferPos = res.first->second;
+        }
+
+        Literal *value = nullptr;
+
+        switch (prop->Kind()) {
+            case ir::MethodDefinitionKind::METHOD: {
+                const ir::FunctionExpression *func = prop->Value()->AsFunctionExpression();
+                const util::StringView &internalName = func->Function()->Scope()->InternalName();
+
+                value = pg->Allocator()->New<TaggedLiteral>(LiteralTag::METHOD, internalName);
+                compiled.Set(i);
+                break;
+            }
+            case ir::MethodDefinitionKind::GET:
+            case ir::MethodDefinitionKind::SET: {
+                value = pg->Allocator()->New<NullLiteral>();
+                break;
+            }
+            default: {
+                UNREACHABLE();
+            }
+        }
+
+        literalBuf->ResetLiteral(bufferPos + 1, value);
+    }
+
+    uint32_t litPairs = buf->Size() / 2;
+
+    /* Static items are stored at the end of the buffer */
+    buf->Insert(&staticBuf);
+
+    /* The last literal item represents the offset of the first static property. The regular property literal count
+     * is divided by 2 as key/value pairs count as one. */
+    buf->Add(pg->Allocator()->New<NumberLiteral>(litPairs));
+
+    return pg->AddLiteralBuffer(buf);
+}
+
+void ClassDefinition::CompileMissingProperties(compiler::PandaGen *pg, const util::BitSet &compiled,
+                                               compiler::VReg classReg) const
+{
+    const auto &properties = body_;
+
+    compiler::VReg protoReg = pg->AllocReg();
+
+    pg->LoadObjByName(this, classReg, "prototype");
+    pg->StoreAccumulator(this, protoReg);
+
+    for (size_t i = 0; i < properties.size(); i++) {
+        if (!properties[i]->IsMethodDefinition() || compiled.Test(i)) {
+            continue;
+        }
+
+        const ir::MethodDefinition *prop = properties[i]->AsMethodDefinition();
+        compiler::VReg dest = prop->IsStatic() ? classReg : protoReg;
+        compiler::RegScope rs(pg);
+
+        switch (prop->Kind()) {
+            case ir::MethodDefinitionKind::METHOD: {
+                compiler::Operand key = pg->ToPropertyKey(prop->Key(), prop->Computed());
+
+                pg->LoadAccumulator(this, dest);
+                const ir::FunctionExpression *func = prop->Value()->AsFunctionExpression();
+                func->Compile(pg);
+
+                pg->StoreOwnProperty(prop->Value()->Parent(), dest, key);
+                break;
+            }
+            case ir::MethodDefinitionKind::GET:
+            case ir::MethodDefinitionKind::SET: {
+                compiler::VReg keyReg = pg->LoadPropertyKey(prop->Key(), prop->Computed());
+
+                compiler::VReg undef = pg->AllocReg();
+                pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+                pg->StoreAccumulator(this, undef);
+
+                compiler::VReg getter = undef;
+                compiler::VReg setter = undef;
+
+                pg->LoadAccumulator(this, dest);
+
+                compiler::VReg accessor = pg->AllocReg();
+                prop->Value()->Compile(pg);
+                pg->StoreAccumulator(prop->Value(), accessor);
+
+                if (prop->Kind() == ir::MethodDefinitionKind::GET) {
+                    getter = accessor;
+                } else {
+                    setter = accessor;
+                }
+
+                pg->DefineGetterSetterByValue(this, dest, keyReg, getter, setter, prop->Computed());
+                break;
+            }
+            default: {
+                UNREACHABLE();
+            }
+        }
+    }
+
+    pg->LoadAccumulator(this, classReg);
+}
+
+void ClassDefinition::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg classReg = pg->AllocReg();
+    compiler::VReg lexenv = pg->LexEnv();
+
+    compiler::LocalRegScope lrs(pg, scope_);
+
+    compiler::VReg baseReg = CompileHeritageClause(pg);
+    util::StringView ctorId = ctor_->Function()->Scope()->InternalName();
+    util::BitSet compiled(body_.size());
+
+    int32_t bufIdx = CreateClassStaticProperties(pg, compiled);
+    pg->DefineClassWithBuffer(this, ctorId, bufIdx, lexenv, baseReg);
+    if (scope_->Parent()->IsGlobalScope() && ident_) {
+        pg->StoreGlobalLet(this, ident_->Name());
+    }
+    pg->StoreAccumulator(this, classReg);
+    InitializeClassName(pg);
+
+    CompileMissingProperties(pg, compiled, classReg);
+}
+
+checker::Type *ClassDefinition::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/classDefinition.h b/es2panda/ir/base/classDefinition.h
new file mode 100644
index 0000000000000000000000000000000000000000..32a1e3096cc8a835adcdb871b94d4f438f8d17a3
--- /dev/null
+++ b/es2panda/ir/base/classDefinition.h
@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_CLASS_DEFINITION_H
+#define ES2PANDA_PARSER_INCLUDE_AST_CLASS_DEFINITION_H
+
+#include <ir/astNode.h>
+#include <binder/variable.h>
+#include <util/bitset.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class LocalScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class Statement;
+class Identifier;
+class MethodDefinition;
+class TSTypeParameterDeclaration;
+class TSTypeParameterInstantiation;
+class TSClassImplements;
+class TSIndexSignature;
+
+class ClassDefinition : public AstNode {
+public:
+    explicit ClassDefinition(binder::LocalScope *scope, Identifier *ident, TSTypeParameterDeclaration *typeParams,
+                             TSTypeParameterInstantiation *superTypeParams,
+                             ArenaVector<TSClassImplements *> &&implements, MethodDefinition *ctor,
+                             Expression *superClass, ArenaVector<Statement *> &&body,
+                             ArenaVector<TSIndexSignature *> &&indexSignatures, bool declare, bool abstract)
+        : AstNode(AstNodeType::CLASS_DEFINITION),
+          scope_(scope),
+          ident_(ident),
+          typeParams_(typeParams),
+          superTypeParams_(superTypeParams),
+          implements_(std::move(implements)),
+          ctor_(ctor),
+          superClass_(superClass),
+          body_(std::move(body)),
+          indexSignatures_(std::move(indexSignatures)),
+          declare_(declare),
+          abstract_(abstract)
+    {
+    }
+
+    binder::LocalScope *Scope() const
+    {
+        return scope_;
+    }
+
+    const Identifier *Ident() const
+    {
+        return ident_;
+    }
+
+    Expression *Super()
+    {
+        return superClass_;
+    }
+
+    const Expression *Super() const
+    {
+        return superClass_;
+    }
+
+    bool Declare() const
+    {
+        return declare_;
+    }
+
+    bool Abstract() const
+    {
+        return abstract_;
+    }
+
+    ArenaVector<Statement *> &Body()
+    {
+        return body_;
+    }
+
+    const ArenaVector<Statement *> &Body() const
+    {
+        return body_;
+    }
+
+    MethodDefinition *Ctor()
+    {
+        ASSERT(ctor_ != nullptr);
+        return ctor_;
+    }
+
+    const FunctionExpression *Ctor() const;
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    compiler::VReg CompileHeritageClause(compiler::PandaGen *pg) const;
+    void InitializeClassName(compiler::PandaGen *pg) const;
+    int32_t CreateClassStaticProperties(compiler::PandaGen *pg, util::BitSet &compiled) const;
+    void CompileMissingProperties(compiler::PandaGen *pg, const util::BitSet &compiled, compiler::VReg classReg) const;
+
+    binder::LocalScope *scope_;
+    Identifier *ident_;
+    TSTypeParameterDeclaration *typeParams_;
+    TSTypeParameterInstantiation *superTypeParams_;
+    ArenaVector<TSClassImplements *> implements_;
+    MethodDefinition *ctor_;
+    Expression *superClass_;
+    ArenaVector<Statement *> body_;
+    ArenaVector<TSIndexSignature *> indexSignatures_;
+    bool declare_;
+    bool abstract_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/classProperty.cpp b/es2panda/ir/base/classProperty.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b39f7f25305c09baacfd0f5477e573439174f463
--- /dev/null
+++ b/es2panda/ir/base/classProperty.cpp
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "classProperty.h"
+
+#include <ir/astDump.h>
+#include <ir/base/decorator.h>
+#include <ir/expression.h>
+
+#include <cstdint>
+#include <string>
+
+namespace panda::es2panda::ir {
+
+void ClassProperty::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+
+    if (value_) {
+        cb(value_);
+    }
+
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+
+    for (auto *it : decorators_) {
+        cb(it);
+    }
+}
+
+void ClassProperty::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ClassProperty"},
+                 {"key", key_},
+                 {"value", AstDumper::Optional(value_)},
+                 {"accessibility", AstDumper::Optional(AstDumper::ModifierToString(modifiers_))},
+                 {"abstract", AstDumper::Optional((modifiers_ & ModifierFlags::ABSTRACT) != 0)},
+                 {"static", (modifiers_ & ModifierFlags::STATIC) != 0},
+                 {"readonly", (modifiers_ & ModifierFlags::READONLY) != 0},
+                 {"declare", (modifiers_ & ModifierFlags::DECLARE) != 0},
+                 {"optional", (modifiers_ & ModifierFlags::OPTIONAL) != 0},
+                 {"computed", isComputed_},
+                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"definite", AstDumper::Optional(definite_)},
+                 {"decorators", decorators_}});
+}
+
+void ClassProperty::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ClassProperty::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/classProperty.h b/es2panda/ir/base/classProperty.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1bc499436164b6c94607e0cbc42c6925917c496
--- /dev/null
+++ b/es2panda/ir/base/classProperty.h
@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_CLASS_PROPERTY_H
+#define ES2PANDA_PARSER_INCLUDE_AST_CLASS_PROPERTY_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class ClassProperty : public Statement {
+public:
+    explicit ClassProperty(Expression *key, Expression *value, Expression *typeAnnotation, ModifierFlags modifiers,
+                           ArenaVector<Decorator *> &&decorators, bool isComputed, bool definite)
+        : Statement(AstNodeType::CLASS_PROPERTY),
+          key_(key),
+          value_(value),
+          typeAnnotation_(typeAnnotation),
+          modifiers_(modifiers),
+          decorators_(std::move(decorators)),
+          isComputed_(isComputed),
+          definite_(definite)
+    {
+    }
+
+    const Expression *Key() const
+    {
+        return key_;
+    }
+
+    const Expression *Value() const
+    {
+        return value_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    ModifierFlags Modifiers() const
+    {
+        return modifiers_;
+    }
+
+    const ArenaVector<Decorator *> &Decorators() const
+    {
+        return decorators_;
+    }
+
+    bool IsComputed() const
+    {
+        return isComputed_;
+    }
+
+    bool Definite() const
+    {
+        return definite_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *key_;
+    Expression *value_;
+    Expression *typeAnnotation_;
+    ModifierFlags modifiers_;
+    ArenaVector<Decorator *> decorators_;
+    bool isComputed_;
+    bool definite_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/decorator.cpp b/es2panda/ir/base/decorator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..801230527b66ed75ff35e63f5bf4aff5c46edbfa
--- /dev/null
+++ b/es2panda/ir/base/decorator.cpp
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "decorator.h"
+
+#include <ir/expression.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void Decorator::Iterate(const NodeTraverser &cb) const
+{
+    cb(expr_);
+}
+
+void Decorator::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "Decorator"}, {"expression", expr_}});
+}
+
+void Decorator::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *Decorator::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/decorator.h b/es2panda/ir/base/decorator.h
new file mode 100644
index 0000000000000000000000000000000000000000..d01c7f01bf5016b64e8d251500e565383a496ac3
--- /dev/null
+++ b/es2panda/ir/base/decorator.h
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_DECORATOR_H
+#define ES2PANDA_PARSER_INCLUDE_AST_DECORATOR_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+class Expression;
+
+class Decorator : public Statement {
+public:
+    explicit Decorator(Expression *expr) : Statement(AstNodeType::DECORATOR), expr_(expr) {}
+
+    const Expression *Expr() const
+    {
+        return expr_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expr_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/metaProperty.cpp b/es2panda/ir/base/metaProperty.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..17094ce6a53dfdb2a117771a3749cc00446c5fef
--- /dev/null
+++ b/es2panda/ir/base/metaProperty.cpp
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "metaProperty.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void MetaProperty::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void MetaProperty::Dump(ir::AstDumper *dumper) const
+{
+    const char *kind = nullptr;
+
+    switch (kind_) {
+        case MetaPropertyKind::NEW_TARGET: {
+            kind = "new.Target";
+            break;
+        }
+        case MetaPropertyKind::IMPORT_META: {
+            kind = "import.Meta";
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+
+    dumper->Add({{"type", "MetaProperty"}, {"kind", kind}});
+}
+
+void MetaProperty::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    if (kind_ == ir::MetaProperty::MetaPropertyKind::NEW_TARGET) {
+        pg->GetNewTarget(this);
+        return;
+    }
+
+    if (kind_ == ir::MetaProperty::MetaPropertyKind::IMPORT_META) {
+        // TODO()
+        pg->Unimplemented();
+    }
+}
+
+checker::Type *MetaProperty::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/metaProperty.h b/es2panda/ir/base/metaProperty.h
new file mode 100644
index 0000000000000000000000000000000000000000..769455fde8937556ee7c2d4bb728fe6c90c27923
--- /dev/null
+++ b/es2panda/ir/base/metaProperty.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_META_PROPERTY_H
+#define ES2PANDA_PARSER_INCLUDE_AST_META_PROPERTY_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class MetaProperty : public Expression {
+public:
+    enum class MetaPropertyKind { NEW_TARGET, IMPORT_META };
+
+    explicit MetaProperty(MetaPropertyKind kind) : Expression(AstNodeType::META_PROPERTY_EXPRESSION), kind_(kind) {}
+
+    MetaPropertyKind Kind() const
+    {
+        return kind_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    MetaPropertyKind kind_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/methodDefinition.cpp b/es2panda/ir/base/methodDefinition.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a3798ecfba36c1c9dff5df9a485bc50d06a7e7ce
--- /dev/null
+++ b/es2panda/ir/base/methodDefinition.cpp
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "methodDefinition.h"
+
+#include <ir/astDump.h>
+#include <ir/base/decorator.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/expression.h>
+#include <ir/expressions/functionExpression.h>
+
+#include <utility>
+
+namespace panda::es2panda::ir {
+
+const ScriptFunction *MethodDefinition::Function() const
+{
+    return value_->Function();
+}
+
+void MethodDefinition::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+    cb(value_);
+
+    for (auto *it : overloads_) {
+        cb(it);
+    }
+
+    for (auto *it : decorators_) {
+        cb(it);
+    }
+}
+
+void MethodDefinition::Dump(ir::AstDumper *dumper) const
+{
+    const char *kind = nullptr;
+
+    switch (kind_) {
+        case MethodDefinitionKind::CONSTRUCTOR: {
+            kind = "constructor";
+            break;
+        }
+        case MethodDefinitionKind::METHOD: {
+            kind = "method";
+            break;
+        }
+        case MethodDefinitionKind::GET: {
+            kind = "get";
+            break;
+        }
+        case MethodDefinitionKind::SET: {
+            kind = "set";
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+
+    dumper->Add({{"type", "MethodDefinition"},
+                 {"key", key_},
+                 {"kind", kind},
+                 {"accessibility", AstDumper::Optional(AstDumper::ModifierToString(modifiers_))},
+                 {"static", (modifiers_ & ModifierFlags::STATIC) != 0},
+                 {"optional", (modifiers_ & ModifierFlags::OPTIONAL) != 0},
+                 {"computed", isComputed_},
+                 {"value", value_},
+                 {"overloads", overloads_},
+                 {"decorators", decorators_}});
+}
+
+void MethodDefinition::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *MethodDefinition::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/methodDefinition.h b/es2panda/ir/base/methodDefinition.h
new file mode 100644
index 0000000000000000000000000000000000000000..e304cd084e23e350d8457da1bb9b7e676f6fc26b
--- /dev/null
+++ b/es2panda/ir/base/methodDefinition.h
@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_METHOD_DEFINITION_H
+#define ES2PANDA_PARSER_INCLUDE_AST_METHOD_DEFINITION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+class FunctionExpression;
+
+enum class MethodDefinitionKind { CONSTRUCTOR, METHOD, GET, SET };
+
+class MethodDefinition : public Statement {
+public:
+    explicit MethodDefinition(MethodDefinitionKind kind, Expression *key, FunctionExpression *value,
+                              ModifierFlags modifiers, ArenaAllocator *allocator, ArenaVector<Decorator *> &&decorators,
+                              bool isComputed)
+        : Statement(AstNodeType::METHOD_DEFINITION),
+          kind_(kind),
+          key_(key),
+          value_(value),
+          modifiers_(modifiers),
+          overloads_(allocator->Adapter()),
+          decorators_(std::move(decorators)),
+          isComputed_(isComputed)
+    {
+    }
+
+    MethodDefinitionKind Kind() const
+    {
+        return kind_;
+    }
+
+    ModifierFlags Modifiers() const
+    {
+        return modifiers_;
+    }
+
+    const Expression *Key() const
+    {
+        return key_;
+    }
+
+    const FunctionExpression *Value() const
+    {
+        return value_;
+    }
+
+    bool Computed() const
+    {
+        return isComputed_;
+    }
+
+    bool IsStatic() const
+    {
+        return (modifiers_ & ModifierFlags::STATIC) != 0;
+    }
+
+    bool IsOptional() const
+    {
+        return (modifiers_ & ModifierFlags::OPTIONAL) != 0;
+    }
+
+    const ArenaVector<MethodDefinition *> &Overloads() const
+    {
+        return overloads_;
+    }
+
+    const ArenaVector<Decorator *> &Decorators() const
+    {
+        return decorators_;
+    }
+
+    void SetOverloads(ArenaVector<MethodDefinition *> &&overloads)
+    {
+        overloads_ = std::move(overloads);
+    }
+
+    void AddOverload(MethodDefinition *overload)
+    {
+        overloads_.push_back(overload);
+    }
+
+    const ScriptFunction *Function() const;
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    MethodDefinitionKind kind_;
+    Expression *key_;
+    FunctionExpression *value_;
+    ModifierFlags modifiers_;
+    ArenaVector<MethodDefinition *> overloads_;
+    ArenaVector<Decorator *> decorators_;
+    bool isComputed_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/property.cpp b/es2panda/ir/base/property.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5802e381fac4a8a7ee44c1c8616d7938ee2003db
--- /dev/null
+++ b/es2panda/ir/base/property.cpp
@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "property.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/validationInfo.h>
+
+namespace panda::es2panda::ir {
+
+bool Property::ConventibleToPatternProperty()
+{
+    // Object pattern can't contain getter or setter
+    if (IsAccessor() || isMethod_) {
+        return false;
+    }
+
+    switch (value_->Type()) {
+        case AstNodeType::OBJECT_EXPRESSION: {
+            return value_->AsObjectExpression()->ConvertibleToObjectPattern();
+        }
+        case AstNodeType::ARRAY_EXPRESSION: {
+            return value_->AsArrayExpression()->ConvertibleToArrayPattern();
+        }
+        case AstNodeType::ASSIGNMENT_EXPRESSION: {
+            return value_->AsAssignmentExpression()->ConvertibleToAssignmentPattern();
+        }
+        case AstNodeType::META_PROPERTY_EXPRESSION: {
+            return false;
+        }
+        default: {
+            break;
+        }
+    }
+
+    return true;
+}
+
+ValidationInfo Property::ValidateExpression()
+{
+    ValidationInfo info;
+
+    if (!IsComputed() && !IsMethod() && !IsAccessor() && !IsShorthand()) {
+        bool currentIsProto = false;
+
+        if (key_->IsIdentifier()) {
+            currentIsProto = key_->AsIdentifier()->Name().Is("__proto__");
+        } else if (key_->IsStringLiteral()) {
+            currentIsProto = key_->AsStringLiteral()->Str().Is("__proto__");
+        }
+
+        if (currentIsProto) {
+            kind_ = PropertyKind::PROTO;
+        }
+    }
+
+    if (value_) {
+        if (value_->IsAssignmentPattern()) {
+            return {"Invalid shorthand property initializer.", value_->Start()};
+        }
+
+        if (value_->IsObjectExpression()) {
+            info = value_->AsObjectExpression()->ValidateExpression();
+        } else if (value_->IsArrayExpression()) {
+            info = value_->AsArrayExpression()->ValidateExpression();
+        }
+    }
+
+    return info;
+}
+
+void Property::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+    cb(value_);
+}
+
+void Property::Dump(ir::AstDumper *dumper) const
+{
+    const char *kind = nullptr;
+
+    switch (kind_) {
+        case PropertyKind::INIT: {
+            kind = "init";
+            break;
+        }
+        case PropertyKind::PROTO: {
+            kind = "proto";
+            break;
+        }
+        case PropertyKind::GET: {
+            kind = "get";
+            break;
+        }
+        case PropertyKind::SET: {
+            kind = "set";
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+
+    dumper->Add({{"type", "Property"},
+                 {"method", isMethod_},
+                 {"shorthand", isShorthand_},
+                 {"computed", isComputed_},
+                 {"key", key_},
+                 {"value", value_},
+                 {"kind", kind}});
+}
+
+void Property::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *Property::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/property.h b/es2panda/ir/base/property.h
new file mode 100644
index 0000000000000000000000000000000000000000..f47df4b114e986183563d4bd394789c7eda03a9d
--- /dev/null
+++ b/es2panda/ir/base/property.h
@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_PROPERTY_H
+#define ES2PANDA_PARSER_INCLUDE_AST_PROPERTY_H
+
+#include <ir/expression.h>
+#include <ir/validationInfo.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+enum class PropertyKind { INIT, GET, SET, PROTO };
+
+class Property : public Expression {
+public:
+    explicit Property(Expression *key, Expression *value)
+        : Expression(AstNodeType::PROPERTY),
+          kind_(PropertyKind::INIT),
+          key_(key),
+          value_(value),
+          isMethod_(false),
+          isShorthand_(true),
+          isComputed_(false)
+    {
+    }
+
+    explicit Property(PropertyKind kind, Expression *key, Expression *value, bool isMethod, bool isComputed)
+        : Expression(AstNodeType::PROPERTY),
+          kind_(kind),
+          key_(key),
+          value_(value),
+          isMethod_(isMethod),
+          isShorthand_(false),
+          isComputed_(isComputed)
+    {
+    }
+
+    Expression *Key()
+    {
+        return key_;
+    }
+
+    const Expression *Key() const
+    {
+        return key_;
+    }
+
+    const Expression *Value() const
+    {
+        return value_;
+    }
+
+    Expression *Value()
+    {
+        return value_;
+    }
+
+    PropertyKind Kind() const
+    {
+        return kind_;
+    }
+
+    bool IsMethod() const
+    {
+        return isMethod_;
+    }
+
+    bool IsShorthand() const
+    {
+        return isShorthand_;
+    }
+
+    bool IsComputed() const
+    {
+        return isComputed_;
+    }
+
+    bool IsAccessor() const
+    {
+        return IsAccessorKind(kind_);
+    }
+
+    static bool IsAccessorKind(PropertyKind kind)
+    {
+        return kind == PropertyKind::GET || kind == PropertyKind::SET;
+    }
+
+    bool ConventibleToPatternProperty();
+    ValidationInfo ValidateExpression();
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    PropertyKind kind_;
+    Expression *key_;
+    Expression *value_;
+    bool isMethod_;
+    bool isShorthand_;
+    bool isComputed_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/scriptFunction.cpp b/es2panda/ir/base/scriptFunction.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d4d06783480d148f97ac08d55b34c18ca0326fb6
--- /dev/null
+++ b/es2panda/ir/base/scriptFunction.cpp
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "scriptFunction.h"
+
+#include <binder/scope.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/statements/blockStatement.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+size_t ScriptFunction::FormalParamsLength() const
+{
+    size_t length = 0;
+
+    for (const auto *param : params_) {
+        if (param->IsRestElement() || param->IsAssignmentPattern()) {
+            break;
+        }
+
+        length++;
+    }
+
+    return length;
+}
+
+void ScriptFunction::Iterate(const NodeTraverser &cb) const
+{
+    if (id_) {
+        cb(id_);
+    }
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    for (auto *it : params_) {
+        cb(it);
+    }
+
+    if (body_) {
+        cb(body_);
+    }
+}
+
+void ScriptFunction::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ScriptFunction"},
+                 {"id", AstDumper::Nullable(id_)},
+                 {"generator", IsGenerator()},
+                 {"async", IsAsync()},
+                 {"expression", ((flags_ & ir::ScriptFunctionFlags::EXPRESSION) != 0)},
+                 {"params", params_},
+                 {"returnType", AstDumper::Optional(returnTypeAnnotation_)},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"declare", AstDumper::Optional(declare_)},
+                 {"body", AstDumper::Optional(body_)}});
+}
+
+void ScriptFunction::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ScriptFunction::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/scriptFunction.h b/es2panda/ir/base/scriptFunction.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0b1e9403e127baf55fd80de9eb388a02eb1a3ca
--- /dev/null
+++ b/es2panda/ir/base/scriptFunction.h
@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_SCRIPT_FUNCTION_H
+#define ES2PANDA_PARSER_INCLUDE_AST_SCRIPT_FUNCTION_H
+
+#include <ir/astNode.h>
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class FunctionScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterDeclaration;
+
+class ScriptFunction : public AstNode {
+public:
+    explicit ScriptFunction(binder::FunctionScope *scope, ArenaVector<Expression *> &&params,
+                            TSTypeParameterDeclaration *typeParams, AstNode *body, Expression *returnTypeAnnotation,
+                            ir::ScriptFunctionFlags flags, bool declare)
+        : AstNode(AstNodeType::SCRIPT_FUNCTION),
+          scope_(scope),
+          id_(nullptr),
+          params_(std::move(params)),
+          typeParams_(typeParams),
+          body_(body),
+          returnTypeAnnotation_(returnTypeAnnotation),
+          flags_(flags),
+          declare_(declare)
+    {
+    }
+
+    const Identifier *Id() const
+    {
+        return id_;
+    }
+
+    Identifier *Id()
+    {
+        return id_;
+    }
+
+    const ArenaVector<Expression *> &Params() const
+    {
+        return params_;
+    }
+
+    ArenaVector<Expression *> &Params()
+    {
+        return params_;
+    }
+
+    const TSTypeParameterDeclaration *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const AstNode *Body() const
+    {
+        return body_;
+    }
+
+    AstNode *Body()
+    {
+        return body_;
+    }
+
+    const Expression *ReturnTypeAnnotation() const
+    {
+        return returnTypeAnnotation_;
+    }
+
+    bool IsGenerator() const
+    {
+        return (flags_ & ir::ScriptFunctionFlags::GENERATOR) != 0;
+    }
+
+    bool IsAsync() const
+    {
+        return (flags_ & ir::ScriptFunctionFlags::ASYNC) != 0;
+    }
+
+    bool IsArrow() const
+    {
+        return (flags_ & ir::ScriptFunctionFlags::ARROW) != 0;
+    }
+
+    bool IsOverload() const
+    {
+        return (flags_ & ir::ScriptFunctionFlags::OVERLOAD) != 0;
+    }
+
+    bool IsConstructor() const
+    {
+        return (flags_ & ir::ScriptFunctionFlags::CONSTRUCTOR) != 0;
+    }
+
+    bool IsMethod() const
+    {
+        return (flags_ & ir::ScriptFunctionFlags::METHOD) != 0;
+    }
+
+    bool Declare() const
+    {
+        return declare_;
+    }
+
+    void SetIdent(Identifier *id)
+    {
+        id_ = id;
+    }
+
+    void AddFlag(ir::ScriptFunctionFlags flags)
+    {
+        flags_ |= flags;
+    }
+
+    size_t FormalParamsLength() const;
+
+    binder::FunctionScope *Scope() const
+    {
+        return scope_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::FunctionScope *scope_;
+    Identifier *id_;
+    ArenaVector<Expression *> params_;
+    TSTypeParameterDeclaration *typeParams_;
+    AstNode *body_;
+    Expression *returnTypeAnnotation_;
+    ir::ScriptFunctionFlags flags_;
+    bool declare_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/spreadElement.cpp b/es2panda/ir/base/spreadElement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fec7ceadd1df2f5c1dc0541dc8ec76d8f9b8ab75
--- /dev/null
+++ b/es2panda/ir/base/spreadElement.cpp
@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "spreadElement.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/objectExpression.h>
+
+namespace panda::es2panda::ir {
+
+ValidationInfo SpreadElement::ValidateExpression()
+{
+    ValidationInfo info;
+
+    switch (argument_->Type()) {
+        case AstNodeType::OBJECT_EXPRESSION: {
+            info = argument_->AsObjectExpression()->ValidateExpression();
+            break;
+        }
+        case AstNodeType::ARRAY_EXPRESSION: {
+            info = argument_->AsArrayExpression()->ValidateExpression();
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    return info;
+}
+
+bool SpreadElement::ConvertibleToRest(bool isDeclaration, bool allowPattern)
+{
+    bool convResult = true;
+
+    switch (argument_->Type()) {
+        case AstNodeType::ARRAY_EXPRESSION: {
+            convResult = allowPattern && argument_->AsArrayExpression()->ConvertibleToArrayPattern();
+            break;
+        }
+        case AstNodeType::OBJECT_EXPRESSION: {
+            convResult = allowPattern && argument_->AsObjectExpression()->ConvertibleToObjectPattern();
+            break;
+        }
+        case AstNodeType::META_PROPERTY_EXPRESSION:
+        case AstNodeType::CHAIN_EXPRESSION:
+        case AstNodeType::ASSIGNMENT_EXPRESSION: {
+            convResult = false;
+            break;
+        }
+        case AstNodeType::MEMBER_EXPRESSION: {
+            convResult = !isDeclaration;
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    SetType(AstNodeType::REST_ELEMENT);
+    return convResult;
+}
+
+void SpreadElement::SetTsTypeAnnotation(Expression *typeAnnotation)
+{
+    typeAnnotation_ = typeAnnotation;
+}
+
+void SpreadElement::Iterate(const NodeTraverser &cb) const
+{
+    cb(argument_);
+
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+}
+
+void SpreadElement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", (type_ == AstNodeType::SPREAD_ELEMENT) ? "SpreadElement" : "RestElement"},
+                 {"argument", argument_},
+                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
+}
+
+void SpreadElement::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *SpreadElement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/spreadElement.h b/es2panda/ir/base/spreadElement.h
new file mode 100644
index 0000000000000000000000000000000000000000..858ef0122bac8767db0372f25baeffbb3d820c5e
--- /dev/null
+++ b/es2panda/ir/base/spreadElement.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_SPREAD_ELEMENT_H
+#define ES2PANDA_PARSER_INCLUDE_AST_SPREAD_ELEMENT_H
+
+#include <ir/expression.h>
+#include <ir/validationInfo.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class SpreadElement : public Expression {
+public:
+    explicit SpreadElement(AstNodeType nodeType, Expression *argument) : Expression(nodeType), argument_(argument) {}
+
+    const Expression *Argument() const
+    {
+        return argument_;
+    }
+
+    Expression *Argument()
+    {
+        return argument_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    ValidationInfo ValidateExpression();
+    bool ConvertibleToRest(bool isDeclaration, bool allowPattern = true);
+
+    void SetTsTypeAnnotation(Expression *typeAnnotation) override;
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *argument_;
+    Expression *typeAnnotation_ {};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/base/templateElement.cpp b/es2panda/ir/base/templateElement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0e843b5944fd30f35331f0ec14475795e677cbc
--- /dev/null
+++ b/es2panda/ir/base/templateElement.cpp
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "templateElement.h"
+
+#include <ir/astDump.h>
+#include <util/ustring.h>
+
+#include <utility>
+
+namespace panda::es2panda::ir {
+
+void TemplateElement::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TemplateElement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({
+        {"type", "TemplateElement"},
+        {"value", {{"raw", "" /* raw_ */}, {"cooked", "" /* cooked_ */}}},
+    });
+}
+
+void TemplateElement::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TemplateElement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/base/templateElement.h b/es2panda/ir/base/templateElement.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0d136262e51dc020d32c180d87cbfcce30c6e31
--- /dev/null
+++ b/es2panda/ir/base/templateElement.h
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_TEMPLATE_ELEMENT_H
+#define ES2PANDA_PARSER_INCLUDE_AST_TEMPLATE_ELEMENT_H
+
+#include <ir/expression.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TemplateElement : public Expression {
+public:
+    explicit TemplateElement() : Expression(AstNodeType::TEMPLATE_ELEMENT) {}
+
+    explicit TemplateElement(util::StringView raw, util::StringView cooked)
+        : Expression(AstNodeType::TEMPLATE_ELEMENT), raw_(raw), cooked_(cooked)
+    {
+    }
+
+    const util::StringView &Raw() const
+    {
+        return raw_;
+    }
+
+    const util::StringView &Cooked() const
+    {
+        return cooked_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    util::StringView raw_ {};
+    util::StringView cooked_ {};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expression.cpp b/es2panda/ir/expression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3f19924adaa61cbf0ca19193cc1cc315a434d1b2
--- /dev/null
+++ b/es2panda/ir/expression.cpp
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "expression.h"
+
+namespace panda::es2panda::ir {
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expression.h b/es2panda/ir/expression.h
new file mode 100644
index 0000000000000000000000000000000000000000..929e6c50e399d3228baaa650d62ac31676adef36
--- /dev/null
+++ b/es2panda/ir/expression.h
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_H
+
+#include <ir/astNode.h>
+
+namespace panda::es2panda::ir {
+
+class Literal;
+
+class Expression : public AstNode {
+public:
+    bool IsGrouped() const
+    {
+        return grouped_;
+    }
+
+    void SetGrouped()
+    {
+        grouped_ = true;
+    }
+
+    const Literal *AsLiteral() const
+    {
+        ASSERT(IsLiteral());
+        return reinterpret_cast<const Literal *>(this);
+    }
+
+    Literal *AsLiteral()
+    {
+        ASSERT(IsLiteral());
+        return reinterpret_cast<Literal *>(this);
+    }
+
+    virtual void SetTsTypeAnnotation([[maybe_unused]] Expression *typeAnnotation)
+    {
+        UNREACHABLE();
+    }
+
+    virtual bool IsLiteral() const
+    {
+        return false;
+    }
+
+    bool IsExpression() const override
+    {
+        return true;
+    }
+
+protected:
+    explicit Expression(AstNodeType type) : AstNode(type) {}
+
+private:
+    bool grouped_ {false};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif /* ES2PANDA_IR_EXPRESSION_H */
diff --git a/es2panda/ir/expressions/arrayExpression.cpp b/es2panda/ir/expressions/arrayExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c2f56bb616224b2b7fc6e0a3c52960952cff0da7
--- /dev/null
+++ b/es2panda/ir/expressions/arrayExpression.cpp
@@ -0,0 +1,359 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arrayExpression.h"
+
+#include <util/helpers.h>
+#include <typescript/checker.h>
+#include <compiler/base/literals.h>
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/objectExpression.h>
+
+namespace panda::es2panda::ir {
+
+bool ArrayExpression::ConvertibleToArrayPattern()
+{
+    bool restFound = false;
+    bool convResult = true;
+    for (auto *it : elements_) {
+        switch (it->Type()) {
+            case AstNodeType::ARRAY_EXPRESSION: {
+                convResult = it->AsArrayExpression()->ConvertibleToArrayPattern();
+                break;
+            }
+            case AstNodeType::SPREAD_ELEMENT: {
+                if (!restFound && it == elements_.back() && !trailingComma_) {
+                    convResult = it->AsSpreadElement()->ConvertibleToRest(isDeclaration_);
+                } else {
+                    convResult = false;
+                }
+                restFound = true;
+                break;
+            }
+            case AstNodeType::OBJECT_EXPRESSION: {
+                convResult = it->AsObjectExpression()->ConvertibleToObjectPattern();
+                break;
+            }
+            case AstNodeType::ASSIGNMENT_EXPRESSION: {
+                convResult = it->AsAssignmentExpression()->ConvertibleToAssignmentPattern();
+                break;
+            }
+            case AstNodeType::META_PROPERTY_EXPRESSION:
+            case AstNodeType::CHAIN_EXPRESSION:
+            case AstNodeType::SEQUENCE_EXPRESSION: {
+                convResult = false;
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
+        if (!convResult) {
+            break;
+        }
+    }
+
+    SetType(AstNodeType::ARRAY_PATTERN);
+    return convResult;
+}
+
+ValidationInfo ArrayExpression::ValidateExpression()
+{
+    ValidationInfo info;
+
+    for (auto *it : elements_) {
+        switch (it->Type()) {
+            case AstNodeType::OBJECT_EXPRESSION: {
+                info = it->AsObjectExpression()->ValidateExpression();
+                break;
+            }
+            case AstNodeType::ARRAY_EXPRESSION: {
+                info = it->AsArrayExpression()->ValidateExpression();
+                break;
+            }
+            case AstNodeType::ASSIGNMENT_EXPRESSION: {
+                auto *assignmentExpr = it->AsAssignmentExpression();
+
+                if (assignmentExpr->Left()->IsArrayExpression()) {
+                    info = assignmentExpr->Left()->AsArrayExpression()->ValidateExpression();
+                } else if (assignmentExpr->Left()->IsObjectExpression()) {
+                    info = assignmentExpr->Left()->AsObjectExpression()->ValidateExpression();
+                }
+
+                break;
+            }
+            case AstNodeType::SPREAD_ELEMENT: {
+                info = it->AsSpreadElement()->ValidateExpression();
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
+        if (info.Fail()) {
+            break;
+        }
+    }
+
+    return info;
+}
+
+void ArrayExpression::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : elements_) {
+        cb(it);
+    }
+
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+}
+
+void ArrayExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", type_ == AstNodeType::ARRAY_EXPRESSION ? "ArrayExpression" : "ArrayPattern"},
+                 {"elements", elements_},
+                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"optional", AstDumper::Optional(optional_)}});
+}
+
+void ArrayExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg arrayObj = pg->AllocReg();
+
+    pg->CreateArray(this, elements_, arrayObj);
+}
+
+checker::Type *GetSpreadElementTypeInArrayLiteral(checker::Checker *checker, const ir::SpreadElement *spreadElement)
+{
+    checker::Type *spreadType = spreadElement->Argument()->Check(checker);
+
+    if (spreadType->IsArrayType()) {
+        return spreadType->AsArrayType()->ElementType();
+    }
+
+    if (spreadType->IsObjectType() && spreadType->AsObjectType()->IsTupleType()) {
+        std::vector<checker::Type *> tupleElementTypes;
+        checker::TupleType *spreadTuple = spreadType->AsObjectType()->AsTupleType();
+        auto *it = spreadTuple->Iterator()->Next();
+
+        while (it) {
+            tupleElementTypes.push_back(it);
+            it = spreadTuple->Iterator()->Next();
+        }
+
+        return checker->CreateUnionType(std::move(tupleElementTypes));
+    }
+
+    if (spreadType->IsUnionType()) {
+        std::vector<checker::Type *> spreadTypes;
+        bool throwError = false;
+
+        for (auto *it : spreadType->AsUnionType()->ConstituentTypes()) {
+            if (it->IsArrayType()) {
+                spreadTypes.push_back(it->AsArrayType()->ElementType());
+                continue;
+            }
+
+            if (it->IsObjectType() && it->AsObjectType()->IsTupleType()) {
+                checker::TupleType *tuple = it->AsObjectType()->AsTupleType();
+                auto *iter = tuple->Iterator()->Next();
+
+                while (iter) {
+                    spreadTypes.push_back(iter);
+                    iter = tuple->Iterator()->Next();
+                }
+
+                continue;
+            }
+
+            throwError = true;
+            break;
+        }
+
+        if (!throwError) {
+            return checker->CreateUnionType(std::move(spreadTypes));
+        }
+    }
+
+    checker->ThrowTypeError(
+        {"Type '", spreadType, "' must have a '[Symbol.Iterator]()' method that returns an iterator."},
+        spreadElement->Start());
+
+    return nullptr;
+}
+
+checker::Type *GetArrayLiteralElementType(checker::Checker *checker, const ir::Expression *expr, bool forceTuple,
+                                          bool noLiteralBaseType, bool destructuringSource, bool readonly)
+{
+    if (expr->IsSpreadElement()) {
+        return GetSpreadElementTypeInArrayLiteral(checker, expr->AsSpreadElement());
+    }
+
+    if (expr->IsOmittedExpression()) {
+        if (forceTuple) {
+            if (destructuringSource) {
+                return checker->GlobalAnyType();
+            }
+
+            return checker->GlobalUndefinedType();
+        }
+
+        return nullptr;
+    }
+
+    // TODO(aszilagyi): params force_tuple, readonly
+
+    checker::Type *returnType = expr->Check(checker);
+
+    if (noLiteralBaseType || readonly) {
+        return returnType;
+    }
+
+    if (returnType->IsEnumType()) {
+        return returnType->AsEnumType()->EnumLiteralVar()->TsType();
+    }
+
+    return checker->GetBaseTypeOfLiteralType(returnType);
+}
+
+checker::Type *ArrayExpression::Check(checker::Checker *checker) const
+{
+    checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+    checker::TupleElementFlagPool elementFlags;
+    std::vector<checker::Type *> elementTypes;
+    uint32_t index = 0;
+    bool forceTuple = (checker->Status() & checker::CheckerStatus::FORCE_TUPLE);
+
+    for (auto *it : elements_) {
+        // TODO(aszilagyi): remove bool params
+        checker::Type *currentElementType = GetArrayLiteralElementType(checker, it, false, false, false, false);
+
+        if (!currentElementType) {
+            continue;
+        }
+
+        if (forceTuple) {
+            util::StringView memberIndex = util::Helpers::ToStringView(checker->Allocator(), index);
+
+            auto *memberVar =
+                binder::Scope::CreateVar(checker->Allocator(), memberIndex, binder::VariableFlags::PROPERTY, it);
+
+            memberVar->AddFlag(binder::VariableFlags::PROPERTY);
+            memberVar->SetTsType(currentElementType);
+            elementFlags.insert({memberIndex, checker::ElementFlags::REQUIRED});
+            desc->properties.push_back(memberVar);
+            index++;
+        }
+
+        if (currentElementType->IsUnionType()) {
+            for (auto *iter : currentElementType->AsUnionType()->ConstituentTypes()) {
+                elementTypes.push_back(iter);
+            }
+
+            continue;
+        }
+
+        elementTypes.push_back(currentElementType);
+    }
+
+    checker::Type *arrayElementType = nullptr;
+    if (elementTypes.empty()) {
+        arrayElementType = checker->GlobalAnyType();
+    } else if (elementTypes.size() == 1) {
+        arrayElementType = elementTypes[0];
+    } else {
+        arrayElementType = checker->CreateUnionType(std::move(elementTypes));
+    }
+
+    if (forceTuple) {
+        // TODO(aszilagyi): handle readonly when creating IndexInfo and TupleType
+        desc->numberIndexInfo = checker->Allocator()->New<checker::IndexInfo>(arrayElementType, "x", false);
+        return checker->CreateTupleType(desc, std::move(elementFlags), checker::ElementFlags::REQUIRED, index, index,
+                                        false);
+    }
+
+    return checker->Allocator()->New<checker::ArrayType>(arrayElementType);
+}
+
+checker::Type *ArrayExpression::CheckPattern(checker::Checker *checker) const
+{
+    checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+    checker::TupleElementFlagPool elementFlags;
+    checker::ElementFlags combinedFlags = checker::ElementFlags::NO_OPTS;
+    uint32_t minLength = 0;
+    uint32_t index = 0;
+
+    for (auto *it : elements_) {
+        checker::Type *elementType = nullptr;
+        checker::ElementFlags memberFlag = checker::ElementFlags::NO_OPTS;
+
+        if (it->IsRestElement()) {
+            elementType = checker->Allocator()->New<checker::ArrayType>(checker->GlobalAnyType());
+            memberFlag = checker::ElementFlags::REST;
+        } else if (it->IsObjectPattern()) {
+            // TODO(aszilagyi): handle inAssignment parameter
+            elementType = it->AsObjectPattern()->CheckPattern(checker, false);
+            memberFlag = checker::ElementFlags::REQUIRED;
+        } else if (it->IsArrayPattern()) {
+            elementType = it->AsArrayPattern()->CheckPattern(checker);
+            memberFlag = checker::ElementFlags::REQUIRED;
+        } else if (it->IsAssignmentPattern()) {
+            const ir::AssignmentExpression *assignmentPattern = it->AsAssignmentPattern();
+
+            if (!assignmentPattern->Left()->IsIdentifier()) {
+                elementType = checker->CreateInitializerTypeForPattern(assignmentPattern->Left()->Check(checker),
+                                                                       assignmentPattern->Right());
+                checker->NodeCache().insert({assignmentPattern->Right(), elementType});
+            } else {
+                elementType = checker->GetBaseTypeOfLiteralType(assignmentPattern->Right()->Check(checker));
+            }
+
+            memberFlag = checker::ElementFlags::OPTIONAL;
+        } else {
+            elementType = checker->GlobalAnyType();
+            memberFlag = checker::ElementFlags::REQUIRED;
+        }
+
+        util::StringView memberIndex = util::Helpers::ToStringView(checker->Allocator(), index);
+
+        auto *memberVar =
+            binder::Scope::CreateVar(checker->Allocator(), memberIndex, binder::VariableFlags::PROPERTY, it);
+
+        if (memberFlag == checker::ElementFlags::OPTIONAL) {
+            memberVar->AddFlag(binder::VariableFlags::OPTIONAL);
+        } else {
+            minLength++;
+        }
+
+        memberVar->SetTsType(elementType);
+        elementFlags.insert({memberIndex, memberFlag});
+        desc->properties.push_back(memberVar);
+
+        combinedFlags |= memberFlag;
+        index++;
+    }
+
+    return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, desc->properties.size(),
+                                    false);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/arrayExpression.h b/es2panda/ir/expressions/arrayExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..eeefb58d668fc1b0b2e540108cb8aaa423b0b9a8
--- /dev/null
+++ b/es2panda/ir/expressions/arrayExpression.h
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_ARRAY_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_ARRAY_EXPRESSION_H
+
+#include <ir/expression.h>
+#include <ir/validationInfo.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+class LiteralBuffer;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ArrayExpression : public Expression {
+public:
+    explicit ArrayExpression(AstNodeType nodeType, ArenaVector<Expression *> &&elements, bool trailingComma)
+        : Expression(nodeType),
+          elements_(std::move(elements)),
+          typeAnnotation_(nullptr),
+          trailingComma_(trailingComma)
+    {
+    }
+
+    const ArenaVector<Expression *> &Elements() const
+    {
+        return elements_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    bool IsDeclaration() const
+    {
+        return isDeclaration_;
+    }
+
+    bool Optional() const
+    {
+        return optional_;
+    }
+
+    void SetDeclaration()
+    {
+        isDeclaration_ = true;
+    }
+
+    void SetOptional(bool optional)
+    {
+        optional_ = optional;
+    }
+
+    bool ConvertibleToArrayPattern();
+    ValidationInfo ValidateExpression();
+
+    void SetTsTypeAnnotation(Expression *typeAnnotation) override
+    {
+        typeAnnotation_ = typeAnnotation;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+    checker::Type *CheckPattern(checker::Checker *checker) const;
+
+private:
+    ArenaVector<Expression *> elements_;
+    Expression *typeAnnotation_;
+    bool isDeclaration_ {};
+    bool trailingComma_;
+    bool optional_ {false};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/arrowFunctionExpression.cpp b/es2panda/ir/expressions/arrowFunctionExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a3ac1816e785f9613e9e2218dc655ff057c6403
--- /dev/null
+++ b/es2panda/ir/expressions/arrowFunctionExpression.cpp
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arrowFunctionExpression.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/expressions/identifier.h>
+#include <ir/statements/variableDeclarator.h>
+
+namespace panda::es2panda::ir {
+
+void ArrowFunctionExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(func_);
+}
+
+void ArrowFunctionExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ArrowFunctionExpression"}, {"function", func_}});
+}
+
+void ArrowFunctionExpression::Compile(compiler::PandaGen *pg) const
+{
+    pg->DefineFunction(func_, func_, func_->Scope()->InternalName());
+}
+
+checker::Type *ArrowFunctionExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    binder::Variable *funcVar = nullptr;
+    const ir::VariableDeclarator *varDecl = nullptr;
+
+    if (func_->Parent()->Parent()->IsVariableDeclarator()) {
+        varDecl = func_->Parent()->Parent()->AsVariableDeclarator();
+    }
+
+    if (varDecl) {
+        ASSERT(varDecl->IsVariableDeclarator());
+        if (varDecl->AsVariableDeclarator()->Id()->IsIdentifier() && !varDecl->Id()->AsIdentifier()->TypeAnnotation()) {
+            const util::StringView &varName = varDecl->AsVariableDeclarator()->Id()->AsIdentifier()->Name();
+
+            binder::ScopeFindResult result = checker->Scope()->Find(varName);
+            ASSERT(result.variable);
+
+            funcVar = result.variable;
+        }
+    }
+
+    checker::ScopeContext scopeCtx(checker, func_->Scope());
+
+    auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
+
+    checker->CheckFunctionParameterDeclaration(func_->Params(), signatureInfo);
+
+    checker::Type *returnType = nullptr;
+
+    if (funcVar) {
+        checker->HandleFunctionReturn(func_, signatureInfo, funcVar);
+        returnType = funcVar->TsType();
+    } else {
+        checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+        desc->callSignatures.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
+        returnType = checker->Allocator()->New<checker::FunctionType>(desc);
+    }
+
+    if (!func_->IsArrow() || !func_->Body()->IsExpression()) {
+        func_->Body()->Check(checker);
+    }
+
+    return returnType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/arrowFunctionExpression.h b/es2panda/ir/expressions/arrowFunctionExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..d848f20284a7c94ee468be6de3a323c49b34e7e7
--- /dev/null
+++ b/es2panda/ir/expressions/arrowFunctionExpression.h
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_ARROW_FUNCTION_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_ARROW_FUNCTION_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ScriptFunction;
+
+class ArrowFunctionExpression : public Expression {
+public:
+    explicit ArrowFunctionExpression(ScriptFunction *func)
+        : Expression(AstNodeType::ARROW_FUNCTION_EXPRESSION), func_(func)
+    {
+    }
+
+    const ScriptFunction *Function() const
+    {
+        return func_;
+    }
+
+    ScriptFunction *Function()
+    {
+        return func_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ScriptFunction *func_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/assignmentExpression.cpp b/es2panda/ir/expressions/assignmentExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..623191b5f220e5f599858db35ca425871bf6aad9
--- /dev/null
+++ b/es2panda/ir/expressions/assignmentExpression.cpp
@@ -0,0 +1,202 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "assignmentExpression.h"
+
+#include <compiler/base/lreference.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/objectExpression.h>
+
+namespace panda::es2panda::ir {
+
+bool AssignmentExpression::ConvertibleToAssignmentPattern(bool mustBePattern)
+{
+    bool convResult = true;
+
+    switch (left_->Type()) {
+        case AstNodeType::ARRAY_EXPRESSION: {
+            convResult = left_->AsArrayExpression()->ConvertibleToArrayPattern();
+            break;
+        }
+        case AstNodeType::SPREAD_ELEMENT: {
+            convResult = mustBePattern && left_->AsSpreadElement()->ConvertibleToRest(false);
+            break;
+        }
+        case AstNodeType::OBJECT_EXPRESSION: {
+            convResult = left_->AsObjectExpression()->ConvertibleToObjectPattern();
+            break;
+        }
+        case AstNodeType::ASSIGNMENT_EXPRESSION: {
+            convResult = left_->AsAssignmentExpression()->ConvertibleToAssignmentPattern(mustBePattern);
+            break;
+        }
+        case AstNodeType::META_PROPERTY_EXPRESSION:
+        case AstNodeType::CHAIN_EXPRESSION: {
+            convResult = false;
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    if (mustBePattern) {
+        SetType(AstNodeType::ASSIGNMENT_PATTERN);
+    }
+
+    if (!right_->IsAssignmentExpression()) {
+        return convResult;
+    }
+
+    switch (right_->Type()) {
+        case AstNodeType::ARRAY_EXPRESSION: {
+            convResult = right_->AsArrayExpression()->ConvertibleToArrayPattern();
+            break;
+        }
+        case AstNodeType::CHAIN_EXPRESSION:
+        case AstNodeType::SPREAD_ELEMENT: {
+            convResult = false;
+            break;
+        }
+        case AstNodeType::OBJECT_EXPRESSION: {
+            convResult = right_->AsObjectExpression()->ConvertibleToObjectPattern();
+            break;
+        }
+        case AstNodeType::ASSIGNMENT_EXPRESSION: {
+            convResult = right_->AsAssignmentExpression()->ConvertibleToAssignmentPattern(false);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    return convResult;
+}
+
+void AssignmentExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(left_);
+    cb(right_);
+}
+
+void AssignmentExpression::Dump(ir::AstDumper *dumper) const
+{
+    if (type_ == AstNodeType::ASSIGNMENT_EXPRESSION) {
+        dumper->Add({{"type", "AssignmentExpression"}, {"operator", operator_}, {"left", left_}, {"right", right_}});
+    } else {
+        dumper->Add({{"type", "AssignmentPattern"}, {"left", left_}, {"right", right_}});
+    }
+}
+
+void AssignmentExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::LReference lref = compiler::LReference::CreateLRef(pg, left_, false);
+
+    if (operator_ == lexer::TokenType::PUNCTUATOR_LOGICAL_AND_EQUAL ||
+        operator_ == lexer::TokenType::PUNCTUATOR_LOGICAL_OR_EQUAL) {
+        pg->Unimplemented();
+    } else if (operator_ != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        compiler::VReg lhsReg = pg->AllocReg();
+
+        lref.GetValue();
+        pg->StoreAccumulator(left_, lhsReg);
+        right_->Compile(pg);
+        pg->Binary(this, operator_, lhsReg);
+    } else {
+        right_->Compile(pg);
+    }
+
+    lref.SetValue();
+}
+
+void AssignmentExpression::CompilePattern(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::LReference lref = compiler::LReference::CreateLRef(pg, left_, false);
+    right_->Compile(pg);
+    lref.SetValue();
+}
+
+checker::Type *AssignmentExpression::Check(checker::Checker *checker) const
+{
+    if (left_->IsArrayPattern()) {
+        auto *leftType = left_->AsArrayPattern()->Check(checker);
+        auto *rightType = checker->CreateInitializerTypeForPattern(leftType, right_);
+        checker->HandleVariableDeclarationWithContext(left_, rightType, checker::VariableBindingContext::REGULAR,
+                                                      checker::DestructuringType::ARRAY_DESTRUCTURING, false, true);
+
+        return rightType;
+    }
+
+    if (left_->IsObjectPattern()) {
+        auto *leftType = left_->AsObjectPattern()->Check(checker);
+        auto *rightType = checker->CreateInitializerTypeForPattern(leftType, right_);
+        checker->HandleVariableDeclarationWithContext(left_, rightType, checker::VariableBindingContext::REGULAR,
+                                                      checker::DestructuringType::OBJECT_DESTRUCTURING, false, true);
+
+        return rightType;
+    }
+
+    auto *leftType = left_->Check(checker);
+
+    if (operator_ == lexer::TokenType::PUNCTUATOR_SUBSTITUTION &&
+        checker->ElaborateElementwise(right_, leftType, left_->Start())) {
+        return right_->Check(checker);
+    }
+
+    auto *rightType = right_->Check(checker);
+
+    switch (operator_) {
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MOD_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MINUS_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL: {
+            return checker->CheckBinaryOperator(leftType, rightType, left_, right_, this, operator_);
+        }
+        case lexer::TokenType::PUNCTUATOR_PLUS_EQUAL: {
+            return checker->CheckPlusOperator(leftType, rightType, left_, right_, this, operator_);
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL: {
+            return checker->CheckCompareOperator(leftType, rightType, left_, right_, this, operator_);
+        }
+        case lexer::TokenType::PUNCTUATOR_SUBSTITUTION: {
+            checker->CheckAssignmentOperator(operator_, left_, leftType, rightType);
+            return rightType;
+        }
+        default: {
+            UNREACHABLE();
+            break;
+        }
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/assignmentExpression.h b/es2panda/ir/expressions/assignmentExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9e7447e3b43d94aeecd91f5a0cba9fdda430b39
--- /dev/null
+++ b/es2panda/ir/expressions/assignmentExpression.h
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_ASSIGNMENT_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_ASSIGNMENT_EXPRESSION_H
+
+#include <ir/expression.h>
+#include <lexer/token/tokenType.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class AssignmentExpression : public Expression {
+public:
+    explicit AssignmentExpression(Expression *left, Expression *right, lexer::TokenType assignmentOperator)
+        : AssignmentExpression(AstNodeType::ASSIGNMENT_EXPRESSION, left, right, assignmentOperator)
+    {
+    }
+
+    explicit AssignmentExpression(AstNodeType type, Expression *left, Expression *right,
+                                  lexer::TokenType assignmentOperator)
+        : Expression(type), left_(left), right_(right), operator_(assignmentOperator)
+    {
+    }
+
+    const Expression *Left() const
+    {
+        return left_;
+    }
+
+    Expression *Left()
+    {
+        return left_;
+    }
+
+    Expression *Right()
+    {
+        return right_;
+    }
+
+    const Expression *Right() const
+    {
+        return right_;
+    }
+
+    lexer::TokenType OperatorType() const
+    {
+        return operator_;
+    }
+
+    bool ConvertibleToAssignmentPattern(bool mustBePattern = true);
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    void CompilePattern(compiler::PandaGen *pg) const;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *left_;
+    Expression *right_;
+    lexer::TokenType operator_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/awaitExpression.cpp b/es2panda/ir/expressions/awaitExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..98e375c017f65da01db39303d212a85ab051315d
--- /dev/null
+++ b/es2panda/ir/expressions/awaitExpression.cpp
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "awaitExpression.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void AwaitExpression::Iterate(const NodeTraverser &cb) const
+{
+    if (argument_) {
+        cb(argument_);
+    }
+}
+
+void AwaitExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "AwaitExpression"}, {"argument", AstDumper::Nullable(argument_)}});
+}
+
+void AwaitExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+
+    if (argument_) {
+        argument_->Compile(pg);
+    } else {
+        pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+    }
+
+    pg->EmitAwait(this);
+}
+
+checker::Type *AwaitExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/awaitExpression.h b/es2panda/ir/expressions/awaitExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..8759f5c05349b624851e0cbe0ad621e0775909ce
--- /dev/null
+++ b/es2panda/ir/expressions/awaitExpression.h
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_AWAIT_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_AWAIT_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class AwaitExpression : public Expression {
+public:
+    explicit AwaitExpression(Expression *argument) : Expression(AstNodeType::AWAIT_EXPRESSION), argument_(argument) {}
+
+    const Expression *Argument() const
+    {
+        return argument_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    Expression *argument_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/binaryExpression.cpp b/es2panda/ir/expressions/binaryExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7423a2dfb2b77762dd586c92af91a76d97420630
--- /dev/null
+++ b/es2panda/ir/expressions/binaryExpression.cpp
@@ -0,0 +1,167 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "binaryExpression.h"
+
+#include <binder/variable.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <lexer/token/tokenType.h>
+
+namespace panda::es2panda::ir {
+
+void BinaryExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(left_);
+    cb(right_);
+}
+
+void BinaryExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", IsLogical() ? "LogicalExpression" : "BinaryExpression"},
+                 {"operator", operator_},
+                 {"left", left_},
+                 {"right", right_}});
+}
+
+void BinaryExpression::CompileLogical(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg lhs = pg->AllocReg();
+
+    if (operator_ == lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING) {
+        // TODO(parser): Nullish Coalesce
+        compiler::PandaGen::Unimplemented();
+    }
+
+    ASSERT(operator_ == lexer::TokenType::PUNCTUATOR_LOGICAL_AND ||
+           operator_ == lexer::TokenType::PUNCTUATOR_LOGICAL_OR);
+    auto *skipRight = pg->AllocLabel();
+    auto *endLabel = pg->AllocLabel();
+
+    // left -> acc -> lhs -> toboolean -> acc -> bool_lhs
+    left_->Compile(pg);
+    pg->StoreAccumulator(this, lhs);
+    pg->ToBoolean(this);
+
+    if (operator_ == lexer::TokenType::PUNCTUATOR_LOGICAL_AND) {
+        pg->BranchIfFalse(this, skipRight);
+    } else {
+        ASSERT(operator_ == lexer::TokenType::PUNCTUATOR_LOGICAL_OR);
+        pg->BranchIfTrue(this, skipRight);
+    }
+
+    // left is true/false(and/or) then right -> acc
+    right_->Compile(pg);
+    pg->Branch(this, endLabel);
+
+    // left is false/true(and/or) then lhs -> acc
+    pg->SetLabel(this, skipRight);
+    pg->LoadAccumulator(this, lhs);
+    pg->SetLabel(this, endLabel);
+}
+
+void BinaryExpression::Compile(compiler::PandaGen *pg) const
+{
+    if (IsLogical()) {
+        CompileLogical(pg);
+        return;
+    }
+
+    compiler::RegScope rs(pg);
+    compiler::VReg lhs = pg->AllocReg();
+
+    left_->Compile(pg);
+    pg->StoreAccumulator(this, lhs);
+    right_->Compile(pg);
+
+    pg->Binary(this, operator_, lhs);
+}
+
+checker::Type *BinaryExpression::Check(checker::Checker *checker) const
+{
+    auto *leftType = left_->Check(checker);
+
+    if (operator_ == lexer::TokenType::PUNCTUATOR_SUBSTITUTION &&
+        checker->ElaborateElementwise(right_, leftType, left_->Start())) {
+        return right_->Check(checker);
+    }
+
+    auto *rightType = right_->Check(checker);
+
+    switch (operator_) {
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY:
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE:
+        case lexer::TokenType::PUNCTUATOR_MOD:
+        case lexer::TokenType::PUNCTUATOR_MINUS:
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR: {
+            return checker->CheckBinaryOperator(leftType, rightType, left_, right_, this, operator_);
+        }
+        case lexer::TokenType::PUNCTUATOR_PLUS: {
+            return checker->CheckPlusOperator(leftType, rightType, left_, right_, this, operator_);
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN:
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN: {
+            return checker->CheckCompareOperator(leftType, rightType, left_, right_, this, operator_);
+        }
+        case lexer::TokenType::PUNCTUATOR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_NOT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL: {
+            if (checker->IsTypeEqualityComparableTo(leftType, rightType) ||
+                checker->IsTypeEqualityComparableTo(rightType, leftType)) {
+                return checker->GlobalBooleanType();
+            }
+
+            checker->ThrowBinaryLikeError(operator_, leftType, rightType, Start());
+        }
+        case lexer::TokenType::KEYW_INSTANCEOF: {
+            return checker->CheckInstanceofExpression(leftType, rightType, right_, this);
+        }
+        case lexer::TokenType::KEYW_IN: {
+            return checker->CheckInExpression(leftType, rightType, left_, right_, this);
+        }
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_AND: {
+            return checker->CheckAndOperator(leftType, rightType, left_);
+        }
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_OR: {
+            return checker->CheckOrOperator(leftType, rightType, left_);
+        }
+        case lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING: {
+            // TODO(Csaba Repasi): Implement checker for nullish coalescing
+            return checker->GlobalAnyType();
+        }
+        case lexer::TokenType::PUNCTUATOR_SUBSTITUTION: {
+            checker->CheckAssignmentOperator(operator_, left_, leftType, rightType);
+            return rightType;
+        }
+        default: {
+            UNREACHABLE();
+            break;
+        }
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/binaryExpression.h b/es2panda/ir/expressions/binaryExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..f44860fd8243c2c9831a4ccd61f0b3651509ba6b
--- /dev/null
+++ b/es2panda/ir/expressions/binaryExpression.h
@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_BINARY_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_BINARY_EXPRESSION_H
+
+#include <ir/expression.h>
+#include <lexer/token/tokenType.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class BinaryExpression : public Expression {
+public:
+    explicit BinaryExpression(Expression *leftExpr, Expression *rightExpr, lexer::TokenType operatorType)
+        : Expression(AstNodeType::BINARY_EXPRESSION), left_(leftExpr), right_(rightExpr), operator_(operatorType)
+    {
+    }
+
+    const Expression *Left() const
+    {
+        return left_;
+    }
+
+    Expression *Left()
+    {
+        return left_;
+    }
+
+    const Expression *Right() const
+    {
+        return right_;
+    }
+
+    lexer::TokenType OperatorType() const
+    {
+        return operator_;
+    }
+
+    bool IsLogical() const
+    {
+        return operator_ <= lexer::TokenType::PUNCTUATOR_LOGICAL_AND;
+    }
+
+    void SetLeft(Expression *expr)
+    {
+        left_ = expr;
+        SetStart(left_->Start());
+    }
+
+    void SetOperator(lexer::TokenType operatorType)
+    {
+        operator_ = operatorType;
+        type_ = AstNodeType::BINARY_EXPRESSION;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    void CompileLogical(compiler::PandaGen *pg) const;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    Expression *left_;
+    Expression *right_;
+    lexer::TokenType operator_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/callExpression.cpp b/es2panda/ir/expressions/callExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bebd28a6792c0b2889299d8e1c05299841f3b55c
--- /dev/null
+++ b/es2panda/ir/expressions/callExpression.cpp
@@ -0,0 +1,266 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "callExpression.h"
+
+#include <util/helpers.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <typescript/types/objectType.h>
+#include <typescript/types/signature.h>
+#include <typescript/types/type.h>
+#include <ir/astDump.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+
+namespace panda::es2panda::ir {
+
+void CallExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(callee_);
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    for (auto *it : arguments_) {
+        cb(it);
+    }
+}
+
+void CallExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "CallExpression"},
+                 {"callee", callee_},
+                 {"arguments", arguments_},
+                 {"optional", optional_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)}});
+}
+
+compiler::VReg CallExpression::CreateSpreadArguments(compiler::PandaGen *pg) const
+{
+    compiler::VReg argsObj = pg->AllocReg();
+    pg->CreateArray(this, arguments_, argsObj);
+
+    return argsObj;
+}
+
+void CallExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    bool containsSpread = util::Helpers::ContainSpreadElement(arguments_);
+
+    if (callee_->IsSuperExpression()) {
+        if (containsSpread) {
+            compiler::RegScope paramScope(pg);
+            compiler::VReg argsObj = CreateSpreadArguments(pg);
+
+            pg->GetFunctionObject(this);
+            pg->SuperCallSpread(this, argsObj);
+        } else {
+            compiler::RegScope paramScope(pg);
+            compiler::VReg argStart {};
+
+            if (arguments_.empty()) {
+                argStart = pg->AllocReg();
+                pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+                pg->StoreAccumulator(this, argStart);
+            } else {
+                argStart = pg->NextReg();
+            }
+
+            for (const auto *it : arguments_) {
+                compiler::VReg arg = pg->AllocReg();
+                it->Compile(pg);
+                pg->StoreAccumulator(it, arg);
+            }
+
+            pg->GetFunctionObject(this);
+            pg->SuperCall(this, argStart, arguments_.size());
+        }
+
+        compiler::VReg newThis = pg->AllocReg();
+        pg->StoreAccumulator(this, newThis);
+
+        pg->GetThis(this);
+        pg->ThrowIfSuperNotCorrectCall(this, 1);
+
+        pg->LoadAccumulator(this, newThis);
+        pg->SetThis(this);
+        return;
+    }
+
+    compiler::VReg callee = pg->AllocReg();
+    bool hasThis = false;
+    compiler::VReg thisReg {};
+
+    if (callee_->IsMemberExpression()) {
+        hasThis = true;
+        thisReg = pg->AllocReg();
+
+        compiler::RegScope mrs(pg);
+        callee_->AsMemberExpression()->Compile(pg, thisReg);
+    } else {
+        callee_->Compile(pg);
+    }
+
+    pg->StoreAccumulator(this, callee);
+
+    if (containsSpread) {
+        if (!hasThis) {
+            thisReg = pg->AllocReg();
+            pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+            pg->StoreAccumulator(this, thisReg);
+        }
+
+        compiler::VReg argsObj = CreateSpreadArguments(pg);
+        pg->CallSpread(this, callee, thisReg, argsObj);
+        return;
+    }
+
+    for (const auto *it : arguments_) {
+        it->Compile(pg);
+        compiler::VReg arg = pg->AllocReg();
+        pg->StoreAccumulator(it, arg);
+    }
+
+    if (hasThis) {
+        pg->CallThis(this, callee, static_cast<int64_t>(arguments_.size() + 1));
+        return;
+    }
+
+    pg->Call(this, callee, arguments_.size());
+}
+
+using ArgRange = std::pair<uint32_t, uint32_t>;
+
+static ArgRange GetArgRange(const std::vector<checker::Signature *> &signatures,
+                            std::vector<checker::Signature *> *potentialSignatures, uint32_t callArgsSize,
+                            bool *haveSignatureWithRest)
+{
+    uint32_t minArg = UINT32_MAX;
+    uint32_t maxArg = 0;
+
+    for (auto *it : signatures) {
+        if (it->RestVar()) {
+            *haveSignatureWithRest = true;
+        }
+
+        if (it->MinArgCount() < minArg) {
+            minArg = it->MinArgCount();
+        }
+
+        if (it->Params().size() > maxArg) {
+            maxArg = it->Params().size();
+        }
+
+        if (callArgsSize >= it->MinArgCount() && (callArgsSize <= it->Params().size() || it->RestVar())) {
+            potentialSignatures->push_back(it);
+        }
+    }
+
+    return {minArg, maxArg};
+}
+
+static bool CallMatchesSignature(checker::Checker *checker, const ArenaVector<ir::Expression *> &args,
+                                 checker::Signature *signature, bool throwError)
+{
+    for (size_t index = 0; index < args.size(); index++) {
+        checker::Type *sigArgType = nullptr;
+        bool validateRestArg = false;
+
+        if (index >= signature->Params().size()) {
+            ASSERT(signature->RestVar());
+            validateRestArg = true;
+            sigArgType = signature->RestVar()->TsType();
+        } else {
+            sigArgType = signature->Params()[index]->TsType();
+        }
+
+        if (validateRestArg || !throwError ||
+            !checker->ElaborateElementwise(args[index], sigArgType, args[index]->Start())) {
+            checker::Type *callArgType = checker->GetBaseTypeOfLiteralType(args[index]->Check(checker));
+            if (!checker->IsTypeAssignableTo(callArgType, sigArgType)) {
+                if (throwError) {
+                    checker->ThrowTypeError({"Argument of type '", callArgType,
+                                             "' is not assignable to parameter of type '", sigArgType, "'."},
+                                            args[index]->Start());
+                }
+
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+checker::Type *CallExpression::Check(checker::Checker *checker) const
+{
+    auto *calleeType = callee_->Check(checker);
+
+    // TODO(aszilagyi): handle optional chain
+    if (calleeType->IsObjectType()) {
+        checker::ObjectType *calleeObj = calleeType->AsObjectType();
+
+        const std::vector<checker::Signature *> &signatures = calleeObj->CallSignatures();
+
+        if (!signatures.empty()) {
+            std::vector<checker::Signature *> potentialSignatures;
+            bool haveSignatureWithRest = false;
+
+            auto argRange = GetArgRange(signatures, &potentialSignatures, arguments_.size(), &haveSignatureWithRest);
+
+            if (potentialSignatures.empty()) {
+                if (haveSignatureWithRest) {
+                    checker->ThrowTypeError(
+                        {"Expected at least ", argRange.first, " arguments, but got ", arguments_.size(), "."},
+                        Start());
+                }
+
+                if (signatures.size() == 1 && argRange.first == argRange.second) {
+                    lexer::SourcePosition loc =
+                        (argRange.first > arguments_.size()) ? Start() : arguments_[argRange.second]->Start();
+                    checker->ThrowTypeError(
+                        {"Expected ", argRange.first, " arguments, but got ", arguments_.size(), "."}, loc);
+                }
+
+                checker->ThrowTypeError(
+                    {"Expected ", argRange.first, "-", argRange.second, " arguments, but got ", arguments_.size()},
+                    Start());
+            }
+
+            checker::Type *returnType = nullptr;
+            for (auto *it : potentialSignatures) {
+                if (CallMatchesSignature(checker, arguments_, it, potentialSignatures.size() == 1)) {
+                    returnType = it->ReturnType();
+                    break;
+                }
+            }
+
+            if (!returnType) {
+                checker->ThrowTypeError("No overload matches this call.", Start());
+            }
+
+            return returnType;
+        }
+    }
+
+    checker->ThrowTypeError("This expression is not callable.", Start());
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/callExpression.h b/es2panda/ir/expressions/callExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..c49d17f3d3bf36792718544c849a72e90f5a8c79
--- /dev/null
+++ b/es2panda/ir/expressions/callExpression.h
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_CALL_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_CALL_EXPRESSION_H
+
+#include <binder/variable.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterInstantiation;
+
+class CallExpression : public Expression {
+public:
+    explicit CallExpression(Expression *callee, ArenaVector<Expression *> &&arguments,
+                            TSTypeParameterInstantiation *typeParams, bool optional)
+        : Expression(AstNodeType::CALL_EXPRESSION),
+          callee_(callee),
+          arguments_(std::move(arguments)),
+          typeParams_(typeParams),
+          optional_(optional)
+    {
+    }
+
+    const Expression *Callee() const
+    {
+        return callee_;
+    }
+
+    const TSTypeParameterInstantiation *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const ArenaVector<Expression *> &Arguments() const
+    {
+        return arguments_;
+    }
+
+    ArenaVector<Expression *> &Arguments()
+    {
+        return arguments_;
+    }
+
+    void SetTypeParams(TSTypeParameterInstantiation *typeParams)
+    {
+        typeParams_ = typeParams;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    compiler::VReg CreateSpreadArguments(compiler::PandaGen *pg) const;
+
+    Expression *callee_;
+    ArenaVector<Expression *> arguments_;
+    TSTypeParameterInstantiation *typeParams_;
+    bool optional_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/chainExpression.cpp b/es2panda/ir/expressions/chainExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0869146030a2790ec4ab1515f6a239faffe2a89e
--- /dev/null
+++ b/es2panda/ir/expressions/chainExpression.cpp
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "chainExpression.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void ChainExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(expression_);
+}
+
+void ChainExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ChainExpression"}, {"expression", expression_}});
+}
+
+void ChainExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ChainExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return expression_->Check(checker);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/chainExpression.h b/es2panda/ir/expressions/chainExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..571d10c89b262f2047ce8d2b69ffc94cea95987b
--- /dev/null
+++ b/es2panda/ir/expressions/chainExpression.h
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_CHAIN_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_CHAIN_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ChainExpression : public Expression {
+public:
+    explicit ChainExpression(Expression *expression)
+        : Expression(AstNodeType::CHAIN_EXPRESSION), expression_(expression)
+    {
+    }
+
+    const Expression *GetExpression() const
+    {
+        return expression_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expression_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/classExpression.cpp b/es2panda/ir/expressions/classExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..587b573961d183af96775153526dabaf63292c3b
--- /dev/null
+++ b/es2panda/ir/expressions/classExpression.cpp
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "classExpression.h"
+
+#include <ir/astDump.h>
+#include <ir/base/classDefinition.h>
+
+namespace panda::es2panda::ir {
+
+void ClassExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(def_);
+}
+
+void ClassExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ClassExpression"}, {"definition", def_}});
+}
+
+void ClassExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    def_->Compile(pg);
+}
+
+checker::Type *ClassExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/classExpression.h b/es2panda/ir/expressions/classExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..d18df201baf7127725fccfb806845d1ba1946443
--- /dev/null
+++ b/es2panda/ir/expressions/classExpression.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_CLASS_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_CLASS_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ClassDefinition;
+
+class ClassExpression : public Expression {
+public:
+    explicit ClassExpression(ClassDefinition *def) : Expression(AstNodeType::CLASS_EXPRESSION), def_(def) {}
+
+    const ClassDefinition *Definition() const
+    {
+        return def_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ClassDefinition *def_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/conditionalExpression.cpp b/es2panda/ir/expressions/conditionalExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..102342f507a042c9c048c87f64c7a9836ddd333e
--- /dev/null
+++ b/es2panda/ir/expressions/conditionalExpression.cpp
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "conditionalExpression.h"
+
+#include <compiler/base/condition.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void ConditionalExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(test_);
+    cb(consequent_);
+    cb(alternate_);
+}
+
+void ConditionalExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add(
+        {{"type", "ConditionalExpression"}, {"test", test_}, {"consequent", consequent_}, {"alternate", alternate_}});
+}
+
+void ConditionalExpression::Compile(compiler::PandaGen *pg) const
+{
+    auto *falseLabel = pg->AllocLabel();
+    auto *endLabel = pg->AllocLabel();
+
+    compiler::Condition::Compile(pg, test_, falseLabel);
+    consequent_->Compile(pg);
+    pg->Branch(this, endLabel);
+    pg->SetLabel(this, falseLabel);
+    alternate_->Compile(pg);
+    pg->SetLabel(this, endLabel);
+}
+
+checker::Type *ConditionalExpression::Check(checker::Checker *checker) const
+{
+    checker::Type *testType = test_->Check(checker);
+
+    checker->CheckTruthinessOfType(testType, test_->Start());
+    checker->CheckTestingKnownTruthyCallableOrAwaitableType(test_, testType, consequent_);
+
+    checker::Type *consequentType = consequent_->Check(checker);
+    checker::Type *alternateType = alternate_->Check(checker);
+
+    return checker->CreateUnionType({consequentType, alternateType});
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/conditionalExpression.h b/es2panda/ir/expressions/conditionalExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..322802a586fc86be0260159596fd7fd0576922c3
--- /dev/null
+++ b/es2panda/ir/expressions/conditionalExpression.h
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_CONDITIONAL_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_CONDITIONAL_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ConditionalExpression : public Expression {
+public:
+    explicit ConditionalExpression(Expression *test, Expression *consequent, Expression *alternate)
+        : Expression(AstNodeType::CONDITIONAL_EXPRESSION), test_(test), consequent_(consequent), alternate_(alternate)
+    {
+    }
+
+    const Expression *Test() const
+    {
+        return test_;
+    }
+
+    Expression *Test()
+    {
+        return test_;
+    }
+
+    const Expression *Consequent() const
+    {
+        return consequent_;
+    }
+
+    const Expression *Alternate() const
+    {
+        return alternate_;
+    }
+
+    void SetTest(Expression *test)
+    {
+        test_ = test;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *test_;
+    Expression *consequent_;
+    Expression *alternate_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/functionExpression.cpp b/es2panda/ir/expressions/functionExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8a28b2946e372c30b3111ecca52b89e5ad6ebec
--- /dev/null
+++ b/es2panda/ir/expressions/functionExpression.cpp
@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "functionExpression.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/expressions/identifier.h>
+#include <ir/statements/variableDeclarator.h>
+
+namespace panda::es2panda::ir {
+
+void FunctionExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(func_);
+}
+
+void FunctionExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "FunctionExpression"}, {"function", func_}});
+}
+
+void FunctionExpression::Compile(compiler::PandaGen *pg) const
+{
+    pg->DefineFunction(func_, func_, func_->Scope()->InternalName());
+}
+
+checker::Type *FunctionExpression::Check(checker::Checker *checker) const
+{
+    binder::Variable *funcVar = nullptr;
+    const ir::VariableDeclarator *varDecl = nullptr;
+
+    if (func_->Parent()->Parent()->IsVariableDeclarator()) {
+        varDecl = func_->Parent()->Parent()->AsVariableDeclarator();
+    }
+
+    if (varDecl) {
+        ASSERT(varDecl->IsVariableDeclarator());
+        if (varDecl->AsVariableDeclarator()->Id()->IsIdentifier() && !varDecl->Id()->AsIdentifier()->TypeAnnotation()) {
+            const util::StringView &varName = varDecl->AsVariableDeclarator()->Id()->AsIdentifier()->Name();
+
+            binder::ScopeFindResult result = checker->Scope()->Find(varName);
+            ASSERT(result.variable);
+
+            funcVar = result.variable;
+        }
+    }
+
+    checker::ScopeContext scopeCtx(checker, func_->Scope());
+
+    auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
+    checker->CheckFunctionParameterDeclaration(func_->Params(), signatureInfo);
+
+    checker::Type *returnType = nullptr;
+
+    if (funcVar) {
+        checker->HandleFunctionReturn(func_, signatureInfo, funcVar);
+        returnType = funcVar->TsType();
+    } else {
+        checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+        desc->callSignatures.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
+        returnType = checker->Allocator()->New<checker::FunctionType>(desc);
+    }
+
+    if (!func_->IsArrow() || !func_->Body()->IsExpression()) {
+        func_->Body()->Check(checker);
+    }
+
+    return returnType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/functionExpression.h b/es2panda/ir/expressions/functionExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..e94b7fb0f0bc29db604321a635e95b175f854964
--- /dev/null
+++ b/es2panda/ir/expressions/functionExpression.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_FUNCTION_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_FUNCTION_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ScriptFunction;
+
+class FunctionExpression : public Expression {
+public:
+    explicit FunctionExpression(ScriptFunction *func) : Expression(AstNodeType::FUNCTION_EXPRESSION), func_(func) {}
+
+    const ScriptFunction *Function() const
+    {
+        return func_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ScriptFunction *func_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/identifier.cpp b/es2panda/ir/expressions/identifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0132d87cec62dc460508a3a0b7b120f9dd7c0b15
--- /dev/null
+++ b/es2panda/ir/expressions/identifier.cpp
@@ -0,0 +1,151 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "identifier.h"
+
+#include <binder/scope.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/decorator.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void Identifier::Iterate(const NodeTraverser &cb) const
+{
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+
+    for (auto *it : decorators_) {
+        cb(it);
+    }
+}
+
+void Identifier::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "Identifier"},
+                 {"name", name_},
+                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"optional", AstDumper::Optional(IsOptional())},
+                 {"decorators", decorators_}});
+}
+
+void Identifier::Compile(compiler::PandaGen *pg) const
+{
+    binder::ScopeFindResult res = pg->Scope()->Find(name_);
+    if (res.variable) {
+        pg->LoadVar(this, res);
+        return;
+    }
+
+    if (name_.Is("NaN")) {
+        pg->LoadConst(this, compiler::Constant::JS_NAN);
+        return;
+    }
+
+    if (name_.Is("Infinity")) {
+        pg->LoadConst(this, compiler::Constant::JS_INFINITY);
+        return;
+    }
+
+    if (name_.Is("globalThis")) {
+        pg->LoadConst(this, compiler::Constant::JS_GLOBAL);
+        return;
+    }
+
+    if (name_.Is("undefined")) {
+        pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+        return;
+    }
+
+    pg->TryLoadGlobalByName(this, name_);
+}
+
+checker::Type *Identifier::Check(checker::Checker *checker) const
+{
+    if (!variable_) {
+        if (name_.Is("undefined")) {
+            return checker->GlobalUndefinedType();
+        }
+
+        checker->ThrowTypeError({"Cannot find name ", name_}, Start());
+    }
+
+    const binder::Decl *decl = variable_->Declaration();
+
+    if (decl->IsConstDecl() && checker::Checker::InAssignment(this)) {
+        checker->ThrowTypeError({"Cannot assign to '", name_, "' because it is a constant"}, Start());
+    }
+
+    if (!variable_->TsType()) {
+        checker::Type *bindingType = checker->GlobalAnyType();
+        switch (decl->Type()) {
+            case binder::DeclType::CONST:
+            case binder::DeclType::LET: {
+                if (!parent_->IsTSTypeQuery()) {
+                    checker->ThrowTypeError({"Block-scoped variable '", name_, "' used before its declaration"},
+                                            Start());
+                    break;
+                }
+
+                [[fallthrough]];
+            }
+            case binder::DeclType::PARAM:
+            case binder::DeclType::VAR: {
+                bindingType = checker->InferVariableDeclarationType(decl->Node()->AsIdentifier());
+                break;
+            }
+            case binder::DeclType::FUNC: {
+                checker->InferFunctionDeclarationType(decl->AsFunctionDecl(), variable_);
+                return variable_->TsType();
+            }
+            case binder::DeclType::ENUM: {
+                ASSERT(variable_->IsEnumVariable());
+                binder::EnumVariable *enumVar = variable_->AsEnumVariable();
+
+                if (std::holds_alternative<bool>(enumVar->Value())) {
+                    checker->ThrowTypeError(
+                        "A member initializer in a enum declaration cannot reference members declared after it, "
+                        "including "
+                        "members defined in other enums.",
+                        Start());
+                }
+
+                bindingType = std::holds_alternative<double>(enumVar->Value()) ? checker->GlobalNumberType()
+                                                                               : checker->GlobalStringType();
+                break;
+            }
+            case binder::DeclType::ENUM_LITERAL: {
+                UNREACHABLE();  // TODO(aszilagyi)
+            }
+            default: {
+                break;
+            }
+        }
+
+        bindingType->SetVariable(variable_);
+        variable_->SetTsType(bindingType);
+    }
+
+    if (decl->IsInterfaceDecl() || decl->IsTypeAliasDecl()) {
+        checker->ThrowTypeError({name_, " only refers to a type , but is being used as a value here"}, Start());
+    }
+
+    return variable_->TsType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/identifier.h b/es2panda/ir/expressions/identifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cfdf042edaa05909e89191c055afcba1a38fee8
--- /dev/null
+++ b/es2panda/ir/expressions/identifier.h
@@ -0,0 +1,145 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_IDENTIFIER_H
+#define ES2PANDA_IR_EXPRESSION_IDENTIFIER_H
+
+#include <ir/expression.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class Variable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+enum class IdentifierFlags {
+    NONE,
+    OPTIONAL = 1 << 0,
+    REFERENCE = 1 << 1,
+    TDZ = 1 << 2,
+};
+
+DEFINE_BITOPS(IdentifierFlags)
+
+class Identifier : public Expression {
+public:
+    explicit Identifier(util::StringView name, ArenaAllocator *allocator)
+        : Expression(AstNodeType::IDENTIFIER), name_(name), decorators_(allocator->Adapter())
+    {
+    }
+
+    explicit Identifier(util::StringView name, ArenaVector<Decorator *> &&decorators)
+        : Expression(AstNodeType::IDENTIFIER), name_(name), decorators_(std::move(decorators))
+    {
+    }
+
+    explicit Identifier(util::StringView name, Expression *typeAnnotation, ArenaAllocator *allocator)
+        : Expression(AstNodeType::IDENTIFIER),
+          name_(name),
+          typeAnnotation_(typeAnnotation),
+          decorators_(allocator->Adapter())
+    {
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    const util::StringView &Name() const
+    {
+        return name_;
+    }
+
+    const ArenaVector<Decorator *> &Decorators() const
+    {
+        return decorators_;
+    }
+
+    bool IsOptional() const
+    {
+        return (flags_ & IdentifierFlags::OPTIONAL) != 0;
+    }
+
+    void SetOptional(bool optional)
+    {
+        if (optional) {
+            flags_ |= IdentifierFlags::OPTIONAL;
+        } else {
+            flags_ &= ~IdentifierFlags::OPTIONAL;
+        }
+    }
+
+    bool IsReference() const
+    {
+        return (flags_ & IdentifierFlags::REFERENCE) != 0;
+    }
+
+    void SetReference()
+    {
+        flags_ |= IdentifierFlags::REFERENCE;
+    }
+
+    bool IsTdz() const
+    {
+        return (flags_ & IdentifierFlags::TDZ) != 0;
+    }
+
+    void SetTdz()
+    {
+        flags_ |= IdentifierFlags::TDZ;
+    }
+
+    void SetTsTypeAnnotation(Expression *typeAnnotation) override
+    {
+        typeAnnotation_ = typeAnnotation;
+    }
+
+    binder::Variable *Variable() const
+    {
+        return variable_;
+    }
+
+    void SetVariable(binder::Variable *variable)
+    {
+        variable_ = variable;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    util::StringView name_;
+    Expression *typeAnnotation_ {};
+    IdentifierFlags flags_ {IdentifierFlags::NONE};
+    ArenaVector<Decorator *> decorators_;
+    binder::Variable *variable_ {nullptr};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/importExpression.cpp b/es2panda/ir/expressions/importExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11baf3efeb7c87b8cbb54369fa46e94349e26408
--- /dev/null
+++ b/es2panda/ir/expressions/importExpression.cpp
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "importExpression.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void ImportExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(source_);
+}
+
+void ImportExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ImportExpression"}, {"source", source_}});
+}
+
+void ImportExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    pg->Unimplemented();
+}
+
+checker::Type *ImportExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/importExpression.h b/es2panda/ir/expressions/importExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..37328c0b49d11394808de5187de2d14a01ca35ea
--- /dev/null
+++ b/es2panda/ir/expressions/importExpression.h
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_IMPORT_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_IMPORT_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ImportExpression : public Expression {
+public:
+    explicit ImportExpression(Expression *source) : Expression(AstNodeType::IMPORT_EXPRESSION), source_(source) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *source_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/literal.cpp b/es2panda/ir/expressions/literal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48cb9a94d4317a7940cc7c06ae92c416f03258de
--- /dev/null
+++ b/es2panda/ir/expressions/literal.cpp
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "literal.h"
+
+#include <ir/expressions/literals/booleanLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/literals/taggedLiteral.h>
+
+namespace panda::es2panda::ir {
+
+bool Literal::GetBoolean() const
+{
+    ASSERT(IsBooleanLiteral());
+    return AsBooleanLiteral()->Value();
+}
+
+uint32_t Literal::GetInt() const
+{
+    ASSERT(IsNumberLiteral() && AsNumberLiteral()->IsInteger());
+    return AsNumberLiteral()->Number<uint32_t>();
+}
+
+double Literal::GetDouble() const
+{
+    ASSERT(IsNumberLiteral());
+    return AsNumberLiteral()->Number<double>();
+}
+
+const util::StringView &Literal::GetString() const
+{
+    ASSERT(IsStringLiteral());
+    return AsStringLiteral()->Str();
+}
+
+const util::StringView &Literal::GetMethod() const
+{
+    ASSERT(IsTaggedLiteral());
+    return AsTaggedLiteral()->Method();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literal.h b/es2panda/ir/expressions/literal.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee6bc7af23e6d239b26b2b8275c6cb6428c67bb2
--- /dev/null
+++ b/es2panda/ir/expressions/literal.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+// must be kept in sync with panda::panda_file::LiteralTag
+enum class LiteralTag {
+    TAGVALUE,
+    BOOLEAN,
+    INTEGER,
+    FLOAT,
+    DOUBLE,
+    STRING,
+    ACCESSOR,
+    METHOD,
+    GENERATOR_METHOD,
+    ASYNC_GENERATOR_METHOD,
+    NULL_VALUE,
+};
+
+class Literal : public Expression {
+public:
+    bool IsLiteral() const override
+    {
+        return true;
+    }
+
+    virtual LiteralTag Tag() const = 0;
+
+    bool GetBoolean() const;
+    uint32_t GetInt() const;
+    double GetDouble() const;
+    const util::StringView &GetString() const;
+    const util::StringView &GetMethod() const;
+
+protected:
+    explicit Literal(AstNodeType type) : Expression(type) {}
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/literals/bigIntLiteral.cpp b/es2panda/ir/expressions/literals/bigIntLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d3a149f8fad46f96cb87d6e174d1f78383d3cab
--- /dev/null
+++ b/es2panda/ir/expressions/literals/bigIntLiteral.cpp
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bigIntLiteral.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void BigIntLiteral::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void BigIntLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "BigIntLiteral"}, {"value", src_}});
+}
+
+void BigIntLiteral::Compile(compiler::PandaGen *pg) const
+{
+    // TODO()
+    pg->Unimplemented();
+}
+
+checker::Type *BigIntLiteral::Check(checker::Checker *checker) const
+{
+    auto search = checker->BigintLiteralMap().find(src_);
+    if (search != checker->BigintLiteralMap().end()) {
+        return search->second;
+    }
+
+    auto *newBigintLiteralType = checker->Allocator()->New<checker::BigintLiteralType>(src_, false);
+    checker->BigintLiteralMap().insert({src_, newBigintLiteralType});
+    return newBigintLiteralType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literals/bigIntLiteral.h b/es2panda/ir/expressions/literals/bigIntLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..69a2fc99bcc0388decea42fd5e116f47dd427957
--- /dev/null
+++ b/es2panda/ir/expressions/literals/bigIntLiteral.h
@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_BIGINT_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_BIGINT_LITERAL_H
+
+#include <ir/expressions/literal.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class BigIntLiteral : public Literal {
+public:
+    explicit BigIntLiteral(util::StringView src) : Literal(AstNodeType::BIGINT_LITERAL), src_(src) {}
+
+    const util::StringView &Str() const
+    {
+        return src_;
+    }
+
+    LiteralTag Tag() const override
+    {
+        return LiteralTag::NULL_VALUE;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    util::StringView src_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/literals/booleanLiteral.cpp b/es2panda/ir/expressions/literals/booleanLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0dd0f4fca994a2a5f9b89886bfaf60ef1094c91
--- /dev/null
+++ b/es2panda/ir/expressions/literals/booleanLiteral.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "booleanLiteral.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void BooleanLiteral::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void BooleanLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "BooleanLiteral"}, {"value", boolean_}});
+}
+
+void BooleanLiteral::Compile(compiler::PandaGen *pg) const
+{
+    pg->LoadConst(this, boolean_ ? compiler::Constant::JS_TRUE : compiler::Constant::JS_FALSE);
+}
+
+checker::Type *BooleanLiteral::Check(checker::Checker *checker) const
+{
+    return boolean_ ? checker->GlobalTrueType() : checker->GlobalFalseType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literals/booleanLiteral.h b/es2panda/ir/expressions/literals/booleanLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..384a6e36e8c153253d035bad82387423fe228a87
--- /dev/null
+++ b/es2panda/ir/expressions/literals/booleanLiteral.h
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_BOOLEAN_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_BOOLEAN_LITERAL_H
+
+#include <ir/expressions/literal.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class BooleanLiteral : public Literal {
+public:
+    explicit BooleanLiteral(bool value) : Literal(AstNodeType::BOOLEAN_LITERAL), boolean_(value) {}
+
+    bool Value() const
+    {
+        return boolean_;
+    }
+
+    LiteralTag Tag() const override
+    {
+        return LiteralTag::BOOLEAN;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    bool boolean_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/literals/nullLiteral.cpp b/es2panda/ir/expressions/literals/nullLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..67a65c2877b9796a69ff3bc954eb05f613f36645
--- /dev/null
+++ b/es2panda/ir/expressions/literals/nullLiteral.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "nullLiteral.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void NullLiteral::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void NullLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "NullLiteral"}, {"value", AstDumper::Property::Constant::PROP_NULL}});
+}
+
+void NullLiteral::Compile(compiler::PandaGen *pg) const
+{
+    pg->LoadConst(this, compiler::Constant::JS_NULL);
+}
+
+checker::Type *NullLiteral::Check(checker::Checker *checker) const
+{
+    return checker->GlobalNullType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literals/nullLiteral.h b/es2panda/ir/expressions/literals/nullLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc5a9d1da0980c457f305305a6b2755f28240992
--- /dev/null
+++ b/es2panda/ir/expressions/literals/nullLiteral.h
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_NULL_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_NULL_LITERAL_H
+
+#include <ir/expressions/literal.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class NullLiteral : public Literal {
+public:
+    explicit NullLiteral() : Literal(AstNodeType::NULL_LITERAL) {}
+
+    LiteralTag Tag() const override
+    {
+        return LiteralTag::NULL_VALUE;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/literals/numberLiteral.cpp b/es2panda/ir/expressions/literals/numberLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11782233eeb7315f1092fb558b67f2b4dc0875c0
--- /dev/null
+++ b/es2panda/ir/expressions/literals/numberLiteral.cpp
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "numberLiteral.h"
+
+#include <util/helpers.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void NumberLiteral::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void NumberLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "NumberLiteral"}, {"value", number_}});
+}
+
+bool NumberLiteral::IsInteger() const
+{
+    return util::Helpers::IsInteger<int32_t>(number_);
+}
+
+void NumberLiteral::Compile(compiler::PandaGen *pg) const
+{
+    if (std::isnan(number_)) {
+        pg->LoadConst(this, compiler::Constant::JS_NAN);
+    } else if (!std::isfinite(number_)) {
+        pg->LoadConst(this, compiler::Constant::JS_INFINITY);
+    } else if (util::Helpers::IsInteger<int32_t>(number_)) {
+        pg->LoadAccumulatorInt(this, static_cast<int32_t>(number_));
+    } else {
+        pg->LoadAccumulatorFloat(this, number_);
+    }
+}
+
+checker::Type *NumberLiteral::Check(checker::Checker *checker) const
+{
+    auto search = checker->NumberLiteralMap().find(number_);
+    if (search != checker->NumberLiteralMap().end()) {
+        return search->second;
+    }
+
+    auto *newNumLiteralType = checker->Allocator()->New<checker::NumberLiteralType>(number_);
+    checker->NumberLiteralMap().insert({number_, newNumLiteralType});
+    return newNumLiteralType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literals/numberLiteral.h b/es2panda/ir/expressions/literals/numberLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd61076a815b0c60ee7061893f3aa3fed0f855d6
--- /dev/null
+++ b/es2panda/ir/expressions/literals/numberLiteral.h
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_NUMBER_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_NUMBER_LITERAL_H
+
+#include <ir/expressions/literal.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class NumberLiteral : public Literal {
+public:
+    explicit NumberLiteral(double num) : Literal(AstNodeType::NUMBER_LITERAL), number_(num) {}
+    explicit NumberLiteral(double num, util::StringView str)
+        : Literal(AstNodeType::NUMBER_LITERAL), number_(num), str_(str)
+    {
+    }
+
+    template <typename T = double>
+    T Number() const
+    {
+        return static_cast<T>(number_);
+    }
+
+    const util::StringView &Str() const
+    {
+        return str_;
+    }
+
+    LiteralTag Tag() const override
+    {
+        return IsInteger() ? LiteralTag::INTEGER : LiteralTag::DOUBLE;
+    }
+
+    bool operator==(const NumberLiteral &other) const
+    {
+        return number_ == other.number_;
+    }
+
+    bool IsInteger() const;
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    double number_;
+    util::StringView str_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif /* NUMBER_LITERAL_H */
diff --git a/es2panda/ir/expressions/literals/regExpLiteral.cpp b/es2panda/ir/expressions/literals/regExpLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6fb9c4e3c9406e5597cd8e6d4c32e0f01f96e8c7
--- /dev/null
+++ b/es2panda/ir/expressions/literals/regExpLiteral.cpp
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "regExpLiteral.h"
+
+#include <binder/variable.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void RegExpLiteral::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void RegExpLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "RegExpLiteral"}, {"source", pattern_}, {"flags", flags_}});
+}
+
+void RegExpLiteral::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    /* [ ctor, newTarget, regexpPattern(, regexpFlags) ] */
+    compiler::VReg ctor = pg->AllocReg();
+    compiler::VReg newTarget = pg->AllocReg();
+    compiler::VReg pattern = pg->AllocReg();
+    size_t argCount = 3;
+
+    pg->TryLoadGlobalByName(this, "RegExp");
+    pg->StoreAccumulator(this, ctor);
+    pg->StoreAccumulator(this, newTarget);
+
+    pg->LoadAccumulatorString(this, pattern_);
+    pg->StoreAccumulator(this, pattern);
+
+    if (!flags_.Empty()) {
+        compiler::VReg flag = pg->AllocReg();
+        pg->LoadAccumulatorString(this, flags_);
+        pg->StoreAccumulator(this, flag);
+        argCount++;
+    }
+
+    pg->NewObject(this, ctor, argCount);
+}
+
+checker::Type *RegExpLiteral::Check(checker::Checker *checker) const
+{
+    // TODO(aszilagyi);
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literals/regExpLiteral.h b/es2panda/ir/expressions/literals/regExpLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..649143052aec3e223c364dffca85d0f9489bcdd1
--- /dev/null
+++ b/es2panda/ir/expressions/literals/regExpLiteral.h
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_REGEXP_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_REGEXP_LITERAL_H
+
+#include <ir/expressions/literal.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class RegExpLiteral : public Literal {
+public:
+    explicit RegExpLiteral(util::StringView pattern, util::StringView flags)
+        : Literal(AstNodeType::REGEXP_LITERAL), pattern_(pattern), flags_(flags)
+    {
+    }
+
+    const util::StringView &Pattern() const
+    {
+        return pattern_;
+    }
+
+    const util::StringView &Flags() const
+    {
+        return flags_;
+    }
+
+    LiteralTag Tag() const override
+    {
+        return LiteralTag::NULL_VALUE;
+    };
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    util::StringView pattern_;
+    util::StringView flags_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/literals/stringLiteral.cpp b/es2panda/ir/expressions/literals/stringLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d68d4ea58bff824eb0fe20132b7f37dd3e5c3581
--- /dev/null
+++ b/es2panda/ir/expressions/literals/stringLiteral.cpp
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stringLiteral.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+#include <utility>
+
+namespace panda::es2panda::ir {
+
+void StringLiteral::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void StringLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "StringLiteral"}, {"value", str_}});
+}
+
+void StringLiteral::Compile(compiler::PandaGen *pg) const
+{
+    pg->LoadAccumulatorString(this, str_);
+}
+
+checker::Type *StringLiteral::Check(checker::Checker *checker) const
+{
+    auto search = checker->StringLiteralMap().find(str_);
+    if (search != checker->StringLiteralMap().end()) {
+        return search->second;
+    }
+
+    auto *newStrLiteralType = checker->Allocator()->New<checker::StringLiteralType>(str_);
+    checker->StringLiteralMap().insert({str_, newStrLiteralType});
+
+    return newStrLiteralType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literals/stringLiteral.h b/es2panda/ir/expressions/literals/stringLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ff338957ad035fb971d443ece6fd21654f719b1
--- /dev/null
+++ b/es2panda/ir/expressions/literals/stringLiteral.h
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_STRING_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_STRING_LITERAL_H
+
+#include <ir/expressions/literal.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class StringLiteral : public Literal {
+public:
+    explicit StringLiteral(util::StringView str) : Literal(AstNodeType::STRING_LITERAL), str_(str) {}
+
+    const util::StringView &Str() const
+    {
+        return str_;
+    }
+
+    LiteralTag Tag() const override
+    {
+        return LiteralTag::STRING;
+    }
+
+    bool operator==(const StringLiteral &other) const
+    {
+        return str_ == other.str_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    util::StringView str_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/literals/taggedLiteral.cpp b/es2panda/ir/expressions/literals/taggedLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5c8d455345b6266b6222d8564465c388cc9cba0c
--- /dev/null
+++ b/es2panda/ir/expressions/literals/taggedLiteral.cpp
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "taggedLiteral.h"
+
+#include <ir/astDump.h>
+
+#include <utility>
+
+namespace panda::es2panda::ir {
+void TaggedLiteral::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TaggedLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TaggedLiteral"}, {"value", str_}});
+}
+
+void TaggedLiteral::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    UNREACHABLE();
+}
+
+checker::Type *TaggedLiteral::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    UNREACHABLE();
+}
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/literals/taggedLiteral.h b/es2panda/ir/expressions/literals/taggedLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..69a4b6486a38bd9e10ad389b8551b24fcf30fcea
--- /dev/null
+++ b/es2panda/ir/expressions/literals/taggedLiteral.h
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_LITERAL_TAGGED_LITERAL_H
+#define ES2PANDA_IR_EXPRESSION_LITERAL_TAGGED_LITERAL_H
+
+#include <ir/expressions/literal.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+class TaggedLiteral : public Literal {
+public:
+    explicit TaggedLiteral(LiteralTag tag) : Literal(AstNodeType::TAGGED_LITERAL), tag_(tag) {}
+    explicit TaggedLiteral(LiteralTag tag, util::StringView str)
+        : Literal(AstNodeType::TAGGED_LITERAL), str_(str), tag_(tag)
+    {
+    }
+
+    const util::StringView &Str() const
+    {
+        return str_;
+    }
+
+    bool operator==(const TaggedLiteral &other) const
+    {
+        return tag_ == other.tag_ && str_ == other.str_;
+    }
+
+    LiteralTag Tag() const override
+    {
+        return tag_;
+    }
+
+    const util::StringView &Method() const
+    {
+        ASSERT(tag_ == LiteralTag::ACCESSOR || tag_ == LiteralTag::METHOD || tag_ == LiteralTag::GENERATOR_METHOD ||
+               tag_ == LiteralTag::ASYNC_GENERATOR_METHOD);
+        return str_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    util::StringView str_ {};
+    LiteralTag tag_ {LiteralTag::NULL_VALUE};
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/memberExpression.cpp b/es2panda/ir/expressions/memberExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..98a0923059aab6dfbd8872f6ee2ffbb818dba3ae
--- /dev/null
+++ b/es2panda/ir/expressions/memberExpression.cpp
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "memberExpression.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void MemberExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(object_);
+    cb(property_);
+}
+
+void MemberExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "MemberExpression"},
+                 {"object", object_},
+                 {"property", property_},
+                 {"computed", computed_},
+                 {"optional", optional_}});
+}
+
+void MemberExpression::CompileObject(compiler::PandaGen *pg, compiler::VReg dest) const
+{
+    object_->Compile(pg);
+    pg->StoreAccumulator(this, dest);
+}
+
+compiler::Operand MemberExpression::CompileKey(compiler::PandaGen *pg) const
+{
+    return pg->ToPropertyKey(property_, computed_);
+}
+
+void MemberExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg objReg = pg->AllocReg();
+    CompileObject(pg, objReg);
+    compiler::Operand prop = CompileKey(pg);
+
+    if (object_->IsSuperExpression()) {
+        pg->LoadSuperProperty(this, objReg, prop);
+    } else {
+        pg->LoadObjProperty(this, objReg, prop);
+    }
+}
+
+void MemberExpression::Compile(compiler::PandaGen *pg, compiler::VReg objReg) const
+{
+    CompileObject(pg, objReg);
+    compiler::Operand prop = CompileKey(pg);
+
+    if (object_->IsSuperExpression()) {
+        pg->LoadSuperProperty(this, objReg, prop);
+    } else {
+        pg->LoadObjProperty(this, objReg, prop);
+    }
+}
+
+checker::Type *MemberExpression::Check(checker::Checker *checker) const
+{
+    auto *baseType = object_->Check(checker);
+
+    return checker->ResolveBaseProp(baseType, property_, computed_, Start());
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/memberExpression.h b/es2panda/ir/expressions/memberExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fbac5d816ceb788a8be2810b49a028a8a5dafbf
--- /dev/null
+++ b/es2panda/ir/expressions/memberExpression.h
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_MEMBER_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_MEMBER_EXPRESSION_H
+
+#include <binder/variable.h>
+#include <ir/expression.h>
+#include <ir/irnode.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class MemberExpression : public Expression {
+public:
+    enum class MemberExpressionKind { ELEMENT_ACCESS, PROPERTY_ACCESS };
+
+    explicit MemberExpression(Expression *object, Expression *property, MemberExpressionKind kind,
+                              bool computed, bool optional)
+        : Expression(AstNodeType::MEMBER_EXPRESSION),
+          object_(object),
+          property_(property),
+          kind_(kind),
+          computed_(computed),
+          optional_(optional)
+    {
+    }
+
+    const Expression *Object() const
+    {
+        return object_;
+    }
+
+    const Expression *Property() const
+    {
+        return property_;
+    }
+
+    bool IsComputed() const
+    {
+        return computed_;
+    }
+
+    bool IsOptional() const
+    {
+        return optional_;
+    }
+
+    MemberExpressionKind Kind() const
+    {
+        return kind_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    void Compile(compiler::PandaGen *pg, compiler::VReg objReg) const;
+    void CompileObject(compiler::PandaGen *pg, compiler::VReg dest) const;
+    compiler::Operand CompileKey(compiler::PandaGen *pg) const;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    Expression *object_;
+    Expression *property_;
+    MemberExpressionKind kind_;
+    bool computed_;
+    bool optional_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/newExpression.cpp b/es2panda/ir/expressions/newExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f0836eafe9adc2ee6599202e1b6d7fa13e1e9c68
--- /dev/null
+++ b/es2panda/ir/expressions/newExpression.cpp
@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "newExpression.h"
+
+#include <util/helpers.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void NewExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(callee_);
+
+    for (auto *it : arguments_) {
+        cb(it);
+    }
+}
+
+void NewExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "NewExpression"}, {"callee", callee_}, {"arguments", arguments_}});
+}
+
+void NewExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg ctor = pg->AllocReg();
+    compiler::VReg newTarget = pg->AllocReg();
+
+    callee_->Compile(pg);
+    pg->StoreAccumulator(this, ctor);
+
+    // new.Target will be the same as ctor
+    pg->StoreAccumulator(this, newTarget);
+
+    if (!util::Helpers::ContainSpreadElement(arguments_)) {
+        for (const auto *it : arguments_) {
+            compiler::VReg arg = pg->AllocReg();
+            it->Compile(pg);
+            pg->StoreAccumulator(this, arg);
+        }
+
+        pg->NewObject(this, ctor, arguments_.size() + 2);
+    } else {
+        compiler::VReg argsObj = pg->AllocReg();
+
+        pg->CreateArray(this, arguments_, argsObj);
+        pg->NewObjSpread(this, ctor, newTarget);
+    }
+}
+
+checker::Type *NewExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/newExpression.h b/es2panda/ir/expressions/newExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..cad89d3980a5dae13cef74a6a0dca79740609c5d
--- /dev/null
+++ b/es2panda/ir/expressions/newExpression.h
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_NEW_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_NEW_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class NewExpression : public Expression {
+public:
+    explicit NewExpression(Expression *callee, ArenaVector<Expression *> &&arguments)
+        : Expression(AstNodeType::NEW_EXPRESSION), callee_(callee), arguments_(std::move(arguments))
+    {
+    }
+
+    const Expression *Callee() const
+    {
+        return callee_;
+    }
+
+    const ArenaVector<Expression *> &Arguments() const
+    {
+        return arguments_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    Expression *callee_;
+    ArenaVector<Expression *> arguments_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/objectExpression.cpp b/es2panda/ir/expressions/objectExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bb4e2f62db4a15691492513944b6183cf728bd17
--- /dev/null
+++ b/es2panda/ir/expressions/objectExpression.cpp
@@ -0,0 +1,473 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "objectExpression.h"
+
+#include <util/helpers.h>
+#include <compiler/base/literals.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/property.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/functionExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/nullLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/literals/taggedLiteral.h>
+#include <ir/validationInfo.h>
+#include <util/bitset.h>
+
+namespace panda::es2panda::ir {
+
+ValidationInfo ObjectExpression::ValidateExpression()
+{
+    ValidationInfo info;
+    bool foundProto = false;
+
+    for (auto *it : properties_) {
+        switch (it->Type()) {
+            case AstNodeType::OBJECT_EXPRESSION:
+            case AstNodeType::ARRAY_EXPRESSION: {
+                return {"Unexpected token.", it->Start()};
+            }
+            case AstNodeType::SPREAD_ELEMENT: {
+                info = it->AsSpreadElement()->ValidateExpression();
+                break;
+            }
+            case AstNodeType::PROPERTY: {
+                auto *prop = it->AsProperty();
+                info = prop->ValidateExpression();
+
+                if (prop->Kind() == PropertyKind::PROTO) {
+                    if (foundProto) {
+                        return {"Duplicate __proto__ fields are not allowed in object literals", prop->Key()->Start()};
+                    }
+
+                    foundProto = true;
+                }
+
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
+        if (info.Fail()) {
+            break;
+        }
+    }
+
+    return info;
+}
+
+bool ObjectExpression::ConvertibleToObjectPattern()
+{
+    // TODO(rsipka): throw more precise messages in case of false results
+    bool restFound = false;
+    bool convResult = true;
+
+    for (auto *it : properties_) {
+        switch (it->Type()) {
+            case AstNodeType::ARRAY_EXPRESSION: {
+                convResult = it->AsArrayExpression()->ConvertibleToArrayPattern();
+                break;
+            }
+            case AstNodeType::SPREAD_ELEMENT: {
+                if (!restFound && it == properties_.back() && !trailingComma_) {
+                    convResult = it->AsSpreadElement()->ConvertibleToRest(isDeclaration_, false);
+                } else {
+                    convResult = false;
+                }
+
+                restFound = true;
+                break;
+            }
+            case AstNodeType::OBJECT_EXPRESSION: {
+                convResult = it->AsObjectExpression()->ConvertibleToObjectPattern();
+                break;
+            }
+            case AstNodeType::ASSIGNMENT_EXPRESSION: {
+                convResult = it->AsAssignmentExpression()->ConvertibleToAssignmentPattern();
+                break;
+            }
+            case AstNodeType::META_PROPERTY_EXPRESSION:
+            case AstNodeType::CHAIN_EXPRESSION:
+            case AstNodeType::SEQUENCE_EXPRESSION: {
+                convResult = false;
+                break;
+            }
+            case AstNodeType::PROPERTY: {
+                convResult = it->AsProperty()->ConventibleToPatternProperty();
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
+        if (!convResult) {
+            break;
+        }
+    }
+
+    SetType(AstNodeType::OBJECT_PATTERN);
+    return convResult;
+}
+
+void ObjectExpression::SetDeclaration()
+{
+    isDeclaration_ = true;
+}
+
+void ObjectExpression::SetOptional(bool optional)
+{
+    optional_ = optional;
+}
+
+void ObjectExpression::SetTsTypeAnnotation(Expression *typeAnnotation)
+{
+    typeAnnotation_ = typeAnnotation;
+}
+
+void ObjectExpression::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : properties_) {
+        cb(it);
+    }
+
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+}
+
+void ObjectExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", (type_ == AstNodeType::OBJECT_EXPRESSION) ? "ObjectExpression" : "ObjectPattern"},
+                 {"properties", properties_},
+                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"optional", AstDumper::Optional(optional_)}});
+}
+
+void ObjectExpression::EmitCreateObjectWithBuffer(compiler::PandaGen *pg, compiler::LiteralBuffer *buf,
+                                                  bool hasMethod) const
+{
+    if (buf->IsEmpty()) {
+        pg->CreateEmptyObject(this);
+        return;
+    }
+
+    uint32_t bufIdx = pg->AddLiteralBuffer(buf);
+
+    if (hasMethod) {
+        pg->CreateObjectHavingMethod(this, bufIdx);
+    } else {
+        pg->CreateObjectWithBuffer(this, bufIdx);
+    }
+}
+
+static const Literal *CreateLiteral(compiler::PandaGen *pg, const ir::Property *prop, util::BitSet *compiled,
+                                    size_t propIndex)
+{
+    if (util::Helpers::IsConstantExpr(prop->Value())) {
+        compiled->Set(propIndex);
+        return prop->Value()->AsLiteral();
+    }
+
+    if (prop->Kind() != ir::PropertyKind::INIT) {
+        ASSERT(prop->IsAccessor());
+        return pg->Allocator()->New<TaggedLiteral>(LiteralTag::ACCESSOR);
+    }
+
+    if (prop->IsMethod()) {
+        const ir::ScriptFunction *method = prop->Value()->AsFunctionExpression()->Function();
+
+        LiteralTag tag = LiteralTag::METHOD;
+
+        if (method->IsGenerator()) {
+            tag = LiteralTag::GENERATOR_METHOD;
+
+            if (method->IsAsync()) {
+                tag = LiteralTag::ASYNC_GENERATOR_METHOD;
+            }
+        }
+
+        compiled->Set(propIndex);
+        return pg->Allocator()->New<TaggedLiteral>(tag, method->Scope()->InternalName());
+    }
+
+    return pg->Allocator()->New<NullLiteral>();
+}
+
+void ObjectExpression::CompileStaticProperties(compiler::PandaGen *pg, util::BitSet *compiled) const
+{
+    bool hasMethod = false;
+    bool seenComputed = false;
+    auto *buf = pg->NewLiteralBuffer();
+    std::unordered_map<util::StringView, size_t> propNameMap;
+
+    for (size_t i = 0; i < properties_.size(); i++) {
+        if (properties_[i]->IsSpreadElement()) {
+            seenComputed = true;
+            continue;
+        }
+
+        const ir::Property *prop = properties_[i]->AsProperty();
+
+        if (!util::Helpers::IsConstantPropertyKey(prop->Key(), prop->IsComputed()) ||
+            prop->Kind() == ir::PropertyKind::PROTO) {
+            seenComputed = true;
+            continue;
+        }
+
+        util::StringView name = util::Helpers::LiteralToPropName(prop->Key());
+        size_t bufferPos = buf->Literals().size();
+        auto res = propNameMap.insert({name, bufferPos});
+        if (res.second) {
+            if (seenComputed) {
+                break;
+            }
+
+            buf->Add(pg->Allocator()->New<StringLiteral>(name));
+            buf->Add(nullptr);
+        } else {
+            bufferPos = res.first->second;
+        }
+
+        if (prop->IsMethod()) {
+            hasMethod = true;
+        }
+
+        buf->ResetLiteral(bufferPos + 1, CreateLiteral(pg, prop, compiled, i));
+    }
+
+    EmitCreateObjectWithBuffer(pg, buf, hasMethod);
+}
+
+void ObjectExpression::CompileRemainingProperties(compiler::PandaGen *pg, const util::BitSet *compiled,
+                                                  compiler::VReg objReg) const
+{
+    for (size_t i = 0; i < properties_.size(); i++) {
+        if (compiled->Test(i)) {
+            continue;
+        }
+
+        compiler::RegScope rs(pg);
+
+        if (properties_[i]->IsSpreadElement()) {
+            compiler::VReg srcObj = pg->AllocReg();
+            const ir::SpreadElement *spread = properties_[i]->AsSpreadElement();
+
+            spread->Argument()->Compile(pg);
+            pg->StoreAccumulator(spread, srcObj);
+
+            pg->CopyDataProperties(spread, objReg, srcObj);
+            continue;
+        }
+
+        const ir::Property *prop = properties_[i]->AsProperty();
+
+        switch (prop->Kind()) {
+            case ir::PropertyKind::GET:
+            case ir::PropertyKind::SET: {
+                compiler::VReg key = pg->LoadPropertyKey(prop->Key(), prop->IsComputed());
+
+                compiler::VReg undef = pg->AllocReg();
+                pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+                pg->StoreAccumulator(this, undef);
+
+                compiler::VReg getter = undef;
+                compiler::VReg setter = undef;
+
+                compiler::VReg accessor = pg->AllocReg();
+                pg->LoadAccumulator(prop->Value(), objReg);
+                prop->Value()->Compile(pg);
+                pg->StoreAccumulator(prop->Value(), accessor);
+
+                if (prop->Kind() == ir::PropertyKind::GET) {
+                    getter = accessor;
+                } else {
+                    setter = accessor;
+                }
+
+                pg->DefineGetterSetterByValue(this, objReg, key, getter, setter, prop->IsComputed());
+                break;
+            }
+            case ir::PropertyKind::INIT: {
+                compiler::Operand key = pg->ToPropertyKey(prop->Key(), prop->IsComputed());
+
+                if (prop->IsMethod()) {
+                    pg->LoadAccumulator(prop->Value(), objReg);
+                }
+
+                prop->Value()->Compile(pg);
+                pg->StoreOwnProperty(this, objReg, key);
+                break;
+            }
+            case ir::PropertyKind::PROTO: {
+                prop->Value()->Compile(pg);
+                compiler::VReg proto = pg->AllocReg();
+                pg->StoreAccumulator(this, proto);
+
+                pg->SetObjectWithProto(this, proto, objReg);
+                break;
+            }
+            default: {
+                UNREACHABLE();
+            }
+        }
+    }
+
+    pg->LoadAccumulator(this, objReg);
+}
+
+void ObjectExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    if (properties_.empty()) {
+        pg->CreateEmptyObject(this);
+        return;
+    }
+
+    util::BitSet compiled(properties_.size());
+    CompileStaticProperties(pg, &compiled);
+
+    compiler::RegScope rs(pg);
+    compiler::VReg objReg = pg->AllocReg();
+
+    pg->StoreAccumulator(this, objReg);
+
+    CompileRemainingProperties(pg, &compiled, objReg);
+}
+
+static void CheckPatternProperty(checker::Checker *checker, bool inAssignment, checker::ObjectDescriptor *desc,
+                                 ir::Expression *exp)
+{
+    ASSERT(exp->IsProperty());
+    const ir::Property *prop = exp->AsProperty();
+    checker::Type *propType = checker->GlobalAnyType();
+    bool optional = false;
+    util::StringView propName = checker->ToPropertyName(prop->Key(), checker::TypeFlag::COMPUTED_TYPE_LITERAL_NAME);
+
+    if (prop->Value()->IsObjectPattern()) {
+        propType = prop->Value()->AsObjectPattern()->CheckPattern(checker, inAssignment);
+    } else if (prop->Value()->IsArrayPattern()) {
+        propType = prop->Value()->AsArrayPattern()->CheckPattern(checker);
+    } else if (prop->Value()->IsAssignmentPattern()) {
+        const ir::AssignmentExpression *assignmentPattern = prop->Value()->AsAssignmentPattern();
+
+        if (!assignmentPattern->Left()->IsIdentifier()) {
+            propType = checker->CreateInitializerTypeForPattern(assignmentPattern->Left()->Check(checker),
+                                                                assignmentPattern->Right());
+            checker->NodeCache().insert({assignmentPattern->Right(), propType});
+        } else {
+            propType = checker->GetBaseTypeOfLiteralType(assignmentPattern->Right()->Check(checker));
+        }
+
+        optional = true;
+    } else if (inAssignment) {
+        binder::ScopeFindResult result = checker->Scope()->Find(propName);
+        if (result.variable) {
+            propType = result.variable->TsType();
+        }
+    }
+
+    auto *newProp = binder::Scope::CreateVar(checker->Allocator(), propName, binder::VariableFlags::PROPERTY, prop);
+
+    if (optional) {
+        newProp->AddFlag(binder::VariableFlags::OPTIONAL);
+    }
+
+    newProp->SetTsType(propType);
+    desc->properties.push_back(newProp);
+}
+
+checker::Type *ObjectExpression::CheckPattern(checker::Checker *checker, bool inAssignment) const
+{
+    checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+    bool haveRest = false;
+
+    for (auto *it : properties_) {
+        if (it->IsRestElement()) {
+            ASSERT(it->AsRestElement()->Argument()->IsIdentifier());
+            haveRest = true;
+            util::StringView indexInfoName("x");
+            auto *newIndexInfo = checker->Allocator()->New<checker::IndexInfo>(checker->GlobalAnyType(), indexInfoName);
+            desc->stringIndexInfo = newIndexInfo;
+        } else {
+            CheckPatternProperty(checker, inAssignment, desc, it);
+        }
+    }
+
+    checker::Type *returnType = checker->Allocator()->New<checker::ObjectLiteralType>(desc);
+
+    if (haveRest) {
+        returnType->AsObjectType()->AddObjectFlag(checker::ObjectType::ObjectFlags::HAVE_REST);
+    }
+
+    return returnType;
+}
+
+checker::Type *ObjectExpression::Check(checker::Checker *checker) const
+{
+    checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+    std::vector<checker::Type *> stringIndexTypes;
+
+    /* TODO(dbatyai) */
+    bool readonly = false;
+
+    for (const auto *it : properties_) {
+        if (it->IsProperty()) {
+            checker::ObjectLiteralPropertyInfo propInfo =
+                checker->HandleObjectLiteralProperty(it->AsProperty(), desc, &stringIndexTypes, readonly);
+            if (propInfo.handleNextProp) {
+                continue;
+            }
+
+            if (desc->FindProperty(propInfo.propName)) {
+                checker->ThrowTypeError({"Duplicate identifier '", propInfo.propName, "'."}, it->Start());
+            }
+
+            propInfo.propType = checker->GetBaseTypeOfLiteralType(propInfo.propType);
+            binder::VariableFlags propFlag =
+                it->AsProperty()->IsMethod() ? binder::VariableFlags::METHOD : binder::VariableFlags::PROPERTY;
+            auto *newProp = binder::Scope::CreateVar(checker->Allocator(), propInfo.propName, propFlag, it);
+
+            propInfo.propType->SetVariable(newProp);
+            newProp->SetTsType(propInfo.propType);
+            if (readonly) {
+                propInfo.propType->Variable()->AddFlag(binder::VariableFlags::READONLY);
+            }
+            desc->properties.push_back(newProp);
+        } else {
+            ASSERT(it->IsSpreadElement());
+            checker->HandleSpreadElement(it->AsSpreadElement(), desc, it->Start(), readonly);
+        }
+    }
+
+    checker::Type *stringIndexType = checker->CollectStringIndexInfoTypes(desc, stringIndexTypes);
+
+    if (stringIndexType) {
+        auto *strIndexInfo = checker->Allocator()->New<checker::IndexInfo>(stringIndexType, "x", readonly);
+        desc->stringIndexInfo = strIndexInfo;
+    }
+
+    return checker->Allocator()->New<checker::ObjectLiteralType>(desc);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/objectExpression.h b/es2panda/ir/expressions/objectExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..d09eec73d006f31d0a4aa9dd6e0e35b89852368e
--- /dev/null
+++ b/es2panda/ir/expressions/objectExpression.h
@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_OBJECT_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_OBJECT_EXPRESSION_H
+
+#include <binder/variable.h>
+#include <ir/expression.h>
+#include <ir/validationInfo.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+class LiteralBuffer;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::util {
+class BitSet;
+}  // namespace panda::es2panda::util
+
+namespace panda::es2panda::ir {
+
+class ObjectExpression : public Expression {
+public:
+    explicit ObjectExpression(AstNodeType nodeType, ArenaVector<Expression *> &&properties, bool trailingComma)
+        : Expression(nodeType),
+          properties_(std::move(properties)),
+          typeAnnotation_(nullptr),
+          trailingComma_(trailingComma)
+    {
+    }
+
+    const ArenaVector<Expression *> &Properties() const
+    {
+        return properties_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    bool IsDeclaration() const
+    {
+        return isDeclaration_;
+    }
+
+    bool Optional() const
+    {
+        return optional_;
+    }
+
+    ValidationInfo ValidateExpression();
+    bool ConvertibleToObjectPattern();
+
+    void SetDeclaration();
+    void SetTsTypeAnnotation(Expression *typeAnnotation) override;
+    void SetOptional(bool optional);
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+    checker::Type *CheckPattern(checker::Checker *checker, bool inAssignment) const;
+
+private:
+    void EmitCreateObjectWithBuffer(compiler::PandaGen *pg, compiler::LiteralBuffer *buf, bool hasMethod) const;
+    void CompileStaticProperties(compiler::PandaGen *pg, util::BitSet *compiled) const;
+    void CompileRemainingProperties(compiler::PandaGen *pg, const util::BitSet *compiled, compiler::VReg objReg) const;
+
+    ArenaVector<Expression *> properties_;
+    Expression *typeAnnotation_;
+    bool isDeclaration_ {};
+    bool trailingComma_ {};
+    bool optional_ {false};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/omittedExpression.cpp b/es2panda/ir/expressions/omittedExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..92149492dee5e92920a11a48d0e366f489896824
--- /dev/null
+++ b/es2panda/ir/expressions/omittedExpression.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "omittedExpression.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void OmittedExpression::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void OmittedExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "OmittedExpression"}});
+}
+
+void OmittedExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *OmittedExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/omittedExpression.h b/es2panda/ir/expressions/omittedExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..47ed43dbf7957b5226b0b459c2ccb6966ea1be1b
--- /dev/null
+++ b/es2panda/ir/expressions/omittedExpression.h
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_OMITTED_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_OMITTED_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class OmittedExpression : public Expression {
+public:
+    explicit OmittedExpression() : Expression(AstNodeType::OMITTED_EXPRESSION) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/sequenceExpression.cpp b/es2panda/ir/expressions/sequenceExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..47dd83ec827f869f72616283324c0081a1e25870
--- /dev/null
+++ b/es2panda/ir/expressions/sequenceExpression.cpp
@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "sequenceExpression.h"
+
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void SequenceExpression::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : sequence_) {
+        cb(it);
+    }
+}
+
+void SequenceExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "SequenceExpression"}, {"expressions", sequence_}});
+}
+
+void SequenceExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    for (const auto *it : sequence_) {
+        it->Compile(pg);
+    }
+}
+
+checker::Type *SequenceExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/sequenceExpression.h b/es2panda/ir/expressions/sequenceExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6b41bebd56ddb09e4bec5f5eb5753c3efe2b1d9
--- /dev/null
+++ b/es2panda/ir/expressions/sequenceExpression.h
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_SEQUENCE_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_SEQUENCE_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class SequenceExpression : public Expression {
+public:
+    explicit SequenceExpression(ArenaVector<Expression *> &&sequence)
+        : Expression(AstNodeType::SEQUENCE_EXPRESSION), sequence_(std::move(sequence))
+    {
+    }
+
+    const ArenaVector<Expression *> &Sequence() const
+    {
+        return sequence_;
+    }
+
+    ArenaVector<Expression *> &Sequence()
+    {
+        return sequence_;
+    }
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ArenaVector<Expression *> sequence_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/superExpression.cpp b/es2panda/ir/expressions/superExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8c305d231d643684934bd0067151356685d747a2
--- /dev/null
+++ b/es2panda/ir/expressions/superExpression.cpp
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "superExpression.h"
+
+#include <util/helpers.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void SuperExpression::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void SuperExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "Super"}});
+}
+
+void SuperExpression::Compile(compiler::PandaGen *pg) const
+{
+    pg->GetThis(this);
+
+    const ir::ScriptFunction *func = util::Helpers::GetContainingConstructor(this);
+
+    if (func) {
+        pg->ThrowIfSuperNotCorrectCall(this, 0);
+    }
+}
+
+checker::Type *SuperExpression::Check(checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/superExpression.h b/es2panda/ir/expressions/superExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1cabbd0334aaea2697db804da12d873e75fc64c
--- /dev/null
+++ b/es2panda/ir/expressions/superExpression.h
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_SUPER_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_SUPER_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class SuperExpression : public Expression {
+public:
+    explicit SuperExpression() : Expression(AstNodeType::SUPER_EXPRESSION) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/taggedTemplateExpression.cpp b/es2panda/ir/expressions/taggedTemplateExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..156483238128f3c08159be578dea97e270952b6e
--- /dev/null
+++ b/es2panda/ir/expressions/taggedTemplateExpression.cpp
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "taggedTemplateExpression.h"
+
+#include <binder/variable.h>
+#include <compiler/base/literals.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/templateLiteral.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+
+namespace panda::es2panda::ir {
+
+void TaggedTemplateExpression::Iterate(const NodeTraverser &cb) const
+{
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    cb(tag_);
+    cb(quasi_);
+}
+
+void TaggedTemplateExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TaggedTemplateExpression"},
+                 {"tag", tag_},
+                 {"quasi", quasi_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)}});
+}
+
+void TaggedTemplateExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg callee = pg->AllocReg();
+    bool hasThis = false;
+
+    if (tag_->IsMemberExpression()) {
+        hasThis = true;
+        compiler::VReg thisReg = pg->AllocReg();
+
+        compiler::RegScope mrs(pg);
+        tag_->AsMemberExpression()->Compile(pg, thisReg);
+    } else {
+        tag_->Compile(pg);
+    }
+
+    pg->StoreAccumulator(this, callee);
+
+    compiler::Literals::GetTemplateObject(pg, this);
+    compiler::VReg arg0 = pg->AllocReg();
+    pg->StoreAccumulator(this, arg0);
+
+    for (const auto *element : quasi_->Expressions()) {
+        element->Compile(pg);
+        compiler::VReg arg = pg->AllocReg();
+        pg->StoreAccumulator(element, arg);
+    }
+
+    if (hasThis) {
+        constexpr auto extraParams = 2;
+        pg->CallThis(this, callee, static_cast<int64_t>(quasi_->Expressions().size() + extraParams));
+        return;
+    }
+
+    constexpr auto extraParams = 1;
+    pg->Call(this, callee, quasi_->Expressions().size() + extraParams);
+}
+
+checker::Type *TaggedTemplateExpression::Check(checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/taggedTemplateExpression.h b/es2panda/ir/expressions/taggedTemplateExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..f1a0131631801066a51f6c44e4ae384bbce7ae3f
--- /dev/null
+++ b/es2panda/ir/expressions/taggedTemplateExpression.h
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_TAGGED_TEMPLATE_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_TAGGED_TEMPLATE_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TemplateLiteral;
+class TSTypeParameterInstantiation;
+
+class TaggedTemplateExpression : public Expression {
+public:
+    explicit TaggedTemplateExpression(Expression *tag, TemplateLiteral *quasi,
+                                      TSTypeParameterInstantiation *typeParams)
+        : Expression(AstNodeType::TAGGED_TEMPLATE_EXPRESSION), tag_(tag), quasi_(quasi), typeParams_(typeParams)
+    {
+    }
+
+    const Expression *Tag() const
+    {
+        return tag_;
+    }
+
+    const TemplateLiteral *Quasi() const
+    {
+        return quasi_;
+    }
+
+    const TSTypeParameterInstantiation *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Expression *tag_;
+    TemplateLiteral *quasi_;
+    TSTypeParameterInstantiation *typeParams_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/templateLiteral.cpp b/es2panda/ir/expressions/templateLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e1ba4bce01f7fb6a42e1af169288a16b8b4635e2
--- /dev/null
+++ b/es2panda/ir/expressions/templateLiteral.cpp
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "templateLiteral.h"
+
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/templateElement.h>
+
+namespace panda::es2panda::ir {
+
+void TemplateLiteral::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : expressions_) {
+        cb(it);
+    }
+
+    for (auto *it : quasis_) {
+        cb(it);
+    }
+}
+
+void TemplateLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TemplateLiteral"}, {"expressions", expressions_}, {"quasis", quasis_}});
+}
+
+void TemplateLiteral::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    auto quasisIt = quasis_.begin();
+    auto expressionIt = expressions_.begin();
+
+    pg->LoadAccumulatorString(this, (*quasisIt)->Raw());
+
+    quasisIt++;
+
+    bool isQuais = false;
+    size_t total = quasis_.size() + expressions_.size();
+
+    compiler::RegScope rs(pg);
+    compiler::VReg lhs = pg->AllocReg();
+
+    while (total != 1) {
+        const ir::AstNode *node = nullptr;
+
+        if (isQuais) {
+            pg->StoreAccumulator(*quasisIt, lhs);
+            pg->LoadAccumulatorString(this, (*quasisIt)->Raw());
+
+            node = *quasisIt;
+            quasisIt++;
+        } else {
+            const ir::Expression *element = *expressionIt;
+            pg->StoreAccumulator(element, lhs);
+
+            element->Compile(pg);
+
+            node = element;
+            expressionIt++;
+        }
+
+        pg->Binary(node, lexer::TokenType::PUNCTUATOR_PLUS, lhs);
+
+        isQuais = !isQuais;
+        total--;
+    }
+}
+
+checker::Type *TemplateLiteral::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/templateLiteral.h b/es2panda/ir/expressions/templateLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..751b26d5e567a614c7ad5d695fd5d136b503e282
--- /dev/null
+++ b/es2panda/ir/expressions/templateLiteral.h
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_AST_TEMPLATE_LITERAL_H
+#define ES2PANDA_PARSER_INCLUDE_AST_TEMPLATE_LITERAL_H
+
+#include <ir/base/templateElement.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TemplateLiteral : public Expression {
+public:
+    explicit TemplateLiteral(ArenaVector<TemplateElement *> &&quasis, ArenaVector<Expression *> &&expressions)
+        : Expression(AstNodeType::TEMPLATE_LITERAL), quasis_(std::move(quasis)), expressions_(std::move(expressions))
+    {
+    }
+
+    const ArenaVector<TemplateElement *> &Quasis() const
+    {
+        return quasis_;
+    }
+
+    const ArenaVector<Expression *> &Expressions() const
+    {
+        return expressions_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    ArenaVector<TemplateElement *> quasis_;
+    ArenaVector<Expression *> expressions_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/thisExpression.cpp b/es2panda/ir/expressions/thisExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..920d897cc99f7206a1fae621ec3464ba93bf6140
--- /dev/null
+++ b/es2panda/ir/expressions/thisExpression.cpp
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "thisExpression.h"
+
+#include <util/helpers.h>
+#include <binder/binder.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void ThisExpression::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void ThisExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ThisExpression"}});
+}
+
+void ThisExpression::Compile(compiler::PandaGen *pg) const
+{
+    binder::ScopeFindResult res = pg->Scope()->Find(binder::Binder::MANDATORY_PARAM_THIS);
+
+    ASSERT(res.variable && res.variable->IsLocalVariable());
+    pg->LoadAccFromLexEnv(this, res);
+
+    const ir::ScriptFunction *func = util::Helpers::GetContainingConstructor(this);
+
+    if (func) {
+        pg->ThrowIfSuperNotCorrectCall(this, 0);
+    }
+}
+
+checker::Type *ThisExpression::Check(checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/thisExpression.h b/es2panda/ir/expressions/thisExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..2b7b416230bdb559653f201a0d2926d3f2e58f28
--- /dev/null
+++ b/es2panda/ir/expressions/thisExpression.h
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_THIS_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_THIS_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ThisExpression : public Expression {
+public:
+    explicit ThisExpression() : Expression(AstNodeType::THIS_EXPRESSION) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/unaryExpression.cpp b/es2panda/ir/expressions/unaryExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e6aaf5b0ac6369d441cd46a46cfa2269c972ed6
--- /dev/null
+++ b/es2panda/ir/expressions/unaryExpression.cpp
@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "unaryExpression.h"
+
+#include <binder/variable.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/bigIntLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/memberExpression.h>
+
+namespace panda::es2panda::ir {
+
+void UnaryExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(argument_);
+}
+
+void UnaryExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "UnaryExpression"}, {"operator", operator_}, {"prefix", true}, {"argument", argument_}});
+}
+
+void UnaryExpression::Compile(compiler::PandaGen *pg) const
+{
+    switch (operator_) {
+        case lexer::TokenType::KEYW_DELETE: {
+            if (argument_->IsIdentifier()) {
+                binder::ScopeFindResult result = pg->Scope()->Find(argument_->AsIdentifier()->Name());
+                if (!result.variable || (result.scope->IsGlobalScope() && result.variable->IsGlobalVariable())) {
+                    compiler::RegScope rs(pg);
+                    compiler::VReg variable = pg->AllocReg();
+                    compiler::VReg global = pg->AllocReg();
+
+                    pg->LoadConst(this, compiler::Constant::JS_GLOBAL);
+                    pg->StoreAccumulator(this, global);
+
+                    pg->LoadAccumulatorString(this, argument_->AsIdentifier()->Name());
+                    pg->StoreAccumulator(this, variable);
+
+                    pg->DeleteObjProperty(this, global, variable);
+                } else {
+                    // Otherwise it is a local variable which can't be deleted and we just
+                    // return false.
+                    pg->LoadConst(this, compiler::Constant::JS_FALSE);
+                }
+            } else if (argument_->IsMemberExpression()) {
+                compiler::RegScope rs(pg);
+                compiler::VReg object = pg->AllocReg();
+
+                argument_->AsMemberExpression()->CompileObject(pg, object);
+                compiler::Operand prop = argument_->AsMemberExpression()->CompileKey(pg);
+
+                pg->DeleteObjProperty(this, object, prop);
+            } else {
+                // compile the delete operand.
+                argument_->Compile(pg);
+                // Deleting any value or a result of an expression returns True.
+                pg->LoadConst(this, compiler::Constant::JS_TRUE);
+            }
+            break;
+        }
+        case lexer::TokenType::KEYW_TYPEOF: {
+            if (argument_->IsIdentifier()) {
+                const ir::Identifier *ident = argument_->AsIdentifier();
+
+                binder::ScopeFindResult res = pg->Scope()->Find(ident->Name());
+                if (!res.variable) {
+                    compiler::RegScope rs(pg);
+                    compiler::VReg global = pg->AllocReg();
+
+                    pg->LoadConst(this, compiler::Constant::JS_GLOBAL);
+                    pg->StoreAccumulator(this, global);
+                    pg->LoadObjByName(this, global, ident->Name());
+                } else {
+                    pg->LoadVar(ident, res);
+                }
+            } else {
+                argument_->Compile(pg);
+            }
+
+            pg->TypeOf(this);
+            break;
+        }
+        case lexer::TokenType::KEYW_VOID: {
+            argument_->Compile(pg);
+            pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+            break;
+        }
+        default: {
+            argument_->Compile(pg);
+
+            compiler::RegScope rs(pg);
+            compiler::VReg operandReg = pg->AllocReg();
+            pg->StoreAccumulator(this, operandReg);
+            pg->Unary(this, operator_, operandReg);
+            break;
+        }
+    }
+}
+
+checker::Type *UnaryExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::Type *operandType = argument_->Check(checker);
+
+    if (operator_ == lexer::TokenType::KEYW_TYPEOF) {
+        return operandType;
+    }
+
+    if (operator_ == lexer::TokenType::KEYW_DELETE) {
+        if (!argument_->IsMemberExpression()) {
+            checker->ThrowTypeError("The operand of a delete operator must be a property reference.",
+                                    argument_->Start());
+        }
+
+        const ir::MemberExpression *memberArg = argument_->AsMemberExpression();
+
+        if (memberArg->Property()->IsTSPrivateIdentifier()) {
+            checker->ThrowTypeError("The operand of a delete operator cannot be a private identifier.",
+                                    argument_->Start());
+        }
+
+        binder::Variable *argVar = checker->ResolveObjectProperty(argument_->AsMemberExpression());
+        ASSERT(argVar);
+
+        if (argVar->HasFlag(binder::VariableFlags::READONLY)) {
+            checker->ThrowTypeError("The operand of a delete operator cannot be a readonly property.",
+                                    argument_->Start());
+        }
+
+        if (!argVar->HasFlag(binder::VariableFlags::OPTIONAL)) {
+            checker->ThrowTypeError("The operand of a delete operator must be a optional.", argument_->Start());
+        }
+
+        return checker->GlobalBooleanType();
+    }
+
+    if (argument_->IsLiteral()) {
+        const ir::Literal *lit = argument_->AsLiteral();
+
+        if (lit->IsNumberLiteral()) {
+            auto numberValue = lit->AsNumberLiteral()->Number<double>();
+            if (operator_ == lexer::TokenType::PUNCTUATOR_PLUS) {
+                return checker->CreateNumberLiteralType(numberValue);
+            }
+
+            if (operator_ == lexer::TokenType::PUNCTUATOR_MINUS) {
+                return checker->CreateNumberLiteralType(-numberValue);
+            }
+        } else if (lit->IsBigIntLiteral() && operator_ == lexer::TokenType::PUNCTUATOR_MINUS) {
+            return checker->CreateBigintLiteralType(lit->AsBigIntLiteral()->Str(), true);
+        }
+    }
+
+    switch (operator_) {
+        case lexer::TokenType::PUNCTUATOR_PLUS:
+        case lexer::TokenType::PUNCTUATOR_MINUS:
+        case lexer::TokenType::PUNCTUATOR_TILDE: {
+            checker->CheckNonNullType(operandType, Start());
+            // TODO(aszilagyi): check Symbol like types
+
+            if (operator_ == lexer::TokenType::PUNCTUATOR_PLUS) {
+                if (checker::Checker::MaybeTypeOfKind(operandType, checker::TypeFlag::BIGINT_LIKE)) {
+                    checker->ThrowTypeError({"Operator '+' cannot be applied to type '", operandType, "'"}, Start());
+                }
+
+                return checker->GlobalNumberType();
+            }
+
+            return checker->GetUnaryResultType(operandType);
+        }
+        case lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK: {
+            checker->CheckTruthinessOfType(operandType, Start());
+            auto facts = operandType->GetTypeFacts();
+            if (facts & checker::TypeFacts::TRUTHY) {
+                return checker->GlobalFalseType();
+            }
+
+            if (facts & checker::TypeFacts::FALSY) {
+                return checker->GlobalTrueType();
+            }
+
+            return checker->GlobalBooleanType();
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/unaryExpression.h b/es2panda/ir/expressions/unaryExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e6c5b1d8973d4d5b7412034c41f225dc906e042
--- /dev/null
+++ b/es2panda/ir/expressions/unaryExpression.h
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_UNARY_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_UNARY_EXPRESSION_H
+
+#include <ir/expression.h>
+#include <lexer/token/tokenType.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class UnaryExpression : public Expression {
+public:
+    explicit UnaryExpression(Expression *argument, lexer::TokenType unaryOperator)
+        : Expression(AstNodeType::UNARY_EXPRESSION), argument_(argument), operator_(unaryOperator)
+    {
+    }
+
+    lexer::TokenType OperatorType() const
+    {
+        return operator_;
+    }
+
+    const Expression *Argument() const
+    {
+        return argument_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    Expression *argument_;
+    lexer::TokenType operator_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/updateExpression.cpp b/es2panda/ir/expressions/updateExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37266a38d4c3f08b99c40494fb52b0d217953b02
--- /dev/null
+++ b/es2panda/ir/expressions/updateExpression.cpp
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "updateExpression.h"
+
+#include <binder/variable.h>
+#include <compiler/base/lreference.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/unaryExpression.h>
+
+namespace panda::es2panda::ir {
+
+void UpdateExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(argument_);
+}
+
+void UpdateExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "UpdateExpression"}, {"operator", operator_}, {"prefix", prefix_}, {"argument", argument_}});
+}
+
+void UpdateExpression::Compile(compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg operandReg = pg->AllocReg();
+
+    compiler::LReference lref = compiler::LReference::CreateLRef(pg, argument_, false);
+    lref.GetValue();
+
+    pg->StoreAccumulator(this, operandReg);
+    pg->Unary(this, operator_, operandReg);
+
+    lref.SetValue();
+
+    if (!IsPrefix()) {
+        pg->ToNumber(this, operandReg);
+    }
+}
+
+checker::Type *UpdateExpression::Check(checker::Checker *checker) const
+{
+    checker::Type *operandType = argument_->Check(checker);
+    checker->CheckNonNullType(operandType, Start());
+
+    if (!operandType->HasTypeFlag(checker::TypeFlag::VALID_ARITHMETIC_TYPE)) {
+        checker->ThrowTypeError("An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type.",
+                                Start());
+    }
+
+    checker->CheckReferenceExpression(
+        argument_, "The operand of an increment or decrement operator must be a variable or a property access",
+        "The operand of an increment or decrement operator may not be an optional property access");
+
+    return checker->GetUnaryResultType(operandType);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/updateExpression.h b/es2panda/ir/expressions/updateExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..30514793684f53515cf5022b0bee57b420e792b3
--- /dev/null
+++ b/es2panda/ir/expressions/updateExpression.h
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_UPDATE_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_UPDATE_EXPRESSION_H
+
+#include <ir/expression.h>
+#include <lexer/token/tokenType.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+namespace panda::es2panda::ir {
+
+class UpdateExpression : public Expression {
+public:
+    explicit UpdateExpression(Expression *argument, lexer::TokenType updateOperator, bool isPrefix)
+        : Expression(AstNodeType::UPDATE_EXPRESSION),
+          argument_(argument),
+          operator_(updateOperator),
+          prefix_(isPrefix)
+    {
+        ASSERT(updateOperator == lexer::TokenType::PUNCTUATOR_PLUS_PLUS ||
+               updateOperator == lexer::TokenType::PUNCTUATOR_MINUS_MINUS);
+    }
+
+    lexer::TokenType OperatorType() const
+    {
+        return operator_;
+    }
+
+    const Expression *Argument() const
+    {
+        return argument_;
+    }
+
+    bool IsPrefix() const
+    {
+        return prefix_;
+    }
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *argument_;
+    lexer::TokenType operator_;
+    bool prefix_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/expressions/yieldExpression.cpp b/es2panda/ir/expressions/yieldExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..604db00478dc648203015ce3ff2c7b8d0cce56f2
--- /dev/null
+++ b/es2panda/ir/expressions/yieldExpression.cpp
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "yieldExpression.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/function/generatorFunctionBuilder.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void YieldExpression::Iterate(const NodeTraverser &cb) const
+{
+    if (argument_) {
+        cb(argument_);
+    }
+}
+
+void YieldExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "YieldExpression"}, {"delegate", delegate_}, {"argument", AstDumper::Nullable(argument_)}});
+}
+
+void YieldExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::RegScope rs(pg);
+
+    if (argument_) {
+        argument_->Compile(pg);
+    } else {
+        pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+    }
+
+    if (delegate_) {
+        ASSERT(argument_);
+        pg->FuncBuilder()->YieldStar(this);
+    } else {
+        pg->FuncBuilder()->Yield(this);
+    }
+}
+
+checker::Type *YieldExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi)
+    return checker->GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/expressions/yieldExpression.h b/es2panda/ir/expressions/yieldExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..af9cce60ffb773d59ab3df5dfa98522807e2c817
--- /dev/null
+++ b/es2panda/ir/expressions/yieldExpression.h
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_EXPRESSION_YIELD_EXPRESSION_H
+#define ES2PANDA_IR_EXPRESSION_YIELD_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+class GeneratorFunctionBuilder;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class YieldExpression : public Expression {
+public:
+    explicit YieldExpression(Expression *argument, bool isDelegate)
+        : Expression(AstNodeType::YIELD_EXPRESSION), argument_(argument), delegate_(isDelegate)
+    {
+    }
+
+    bool HasDelegate() const
+    {
+        return delegate_;
+    }
+
+    const Expression *Argument() const
+    {
+        return argument_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile(compiler::PandaGen *pg) const override;
+    checker::Type *Check(checker::Checker *checker) const override;
+
+private:
+    Expression *argument_;
+    bool delegate_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/irnode.h b/es2panda/ir/irnode.h
new file mode 100644
index 0000000000000000000000000000000000000000..1382b7c4edec8e83da5d6cfad465bba23316fa43
--- /dev/null
+++ b/es2panda/ir/irnode.h
@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_IR_IRNODE_H
+#define ES2PANDA_COMPILER_IR_IRNODE_H
+
+#include <lexer/token/sourceLocation.h>
+#include <macros.h>
+#include <util/ustring.h>
+#include <utils/span.h>
+
+#include <cstdint>
+#include <list>
+#include <sstream>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace panda::es2panda::ir {
+class AstNode;
+}  // namespace panda::es2panda::ir
+
+namespace panda::pandasm {
+struct Ins;
+}  // namespace panda::pandasm
+
+namespace panda::es2panda::compiler {
+
+enum class OperandKind {
+    // the least significant bit indicates vreg
+    // the second bit indicates src or dst
+    SRC_VREG,
+    DST_VREG,
+    SRC_DST_VREG,
+    IMM,
+    ID,
+    STRING_ID,
+    LABEL
+};
+
+class FormatItem {
+public:
+    constexpr FormatItem(OperandKind kind, uint32_t bitwidth) : kind_(kind), bitwidth_(bitwidth) {}
+
+    OperandKind Kind() const
+    {
+        return kind_;
+    };
+
+    bool constexpr IsVReg() const
+    {
+        return kind_ == OperandKind::SRC_VREG || kind_ == OperandKind::DST_VREG || kind_ == OperandKind::SRC_DST_VREG;
+    }
+
+    uint32_t Bitwidth() const
+    {
+        return bitwidth_;
+    };
+
+private:
+    OperandKind kind_;
+    uint32_t bitwidth_;
+};
+
+class Format {
+public:
+    constexpr Format(const FormatItem *item, size_t size) : item_(item), size_(size) {}
+
+    panda::Span<const FormatItem> GetFormatItem() const
+    {
+        return panda::Span<const FormatItem>(item_, size_);
+    }
+
+private:
+    const FormatItem *item_;
+    size_t size_;
+};
+
+using Formats = panda::Span<const Format>;
+using VReg = uint16_t;
+
+class Label;
+class IRNode;
+
+using Operand = std::variant<compiler::VReg, double, int64_t, util::StringView, Label *>;
+
+#define FIRST_NODE_OF_FUNCTION (reinterpret_cast<ir::AstNode *>(0x1))
+
+class IRNode {
+public:
+    explicit IRNode(const ir::AstNode *node) : node_(node) {};
+    virtual ~IRNode() = default;
+
+    NO_COPY_SEMANTIC(IRNode);
+    NO_MOVE_SEMANTIC(IRNode);
+
+    const ir::AstNode *Node() const
+    {
+        return node_;
+    }
+
+    static constexpr auto MAX_REG_OPERAND = 5;
+
+    virtual Formats GetFormats() const = 0;
+    virtual size_t Registers([[maybe_unused]] std::array<VReg *, MAX_REG_OPERAND> *regs) = 0;
+    virtual size_t Registers([[maybe_unused]] std::array<const VReg *, MAX_REG_OPERAND> *regs) const = 0;
+    virtual void Transform(panda::pandasm::Ins *ins) const = 0;
+
+private:
+    const ir::AstNode *node_;
+};
+
+}  // namespace panda::es2panda::compiler
+
+#endif
diff --git a/es2panda/ir/module/exportAllDeclaration.cpp b/es2panda/ir/module/exportAllDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0913f07b3677be009c7bab3d10b6b24e2ec7d1e4
--- /dev/null
+++ b/es2panda/ir/module/exportAllDeclaration.cpp
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "exportAllDeclaration.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/stringLiteral.h>
+
+namespace panda::es2panda::ir {
+
+void ExportAllDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(source_);
+
+    if (exported_) {
+        cb(exported_);
+    }
+}
+
+void ExportAllDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ExportAllDeclaration"}, {"source", source_}, {"exported", AstDumper::Nullable(exported_)}});
+}
+
+void ExportAllDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ExportAllDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/exportAllDeclaration.h b/es2panda/ir/module/exportAllDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..f9c94ddff74c55621ec4d6ac6cfb004be6eeca73
--- /dev/null
+++ b/es2panda/ir/module/exportAllDeclaration.h
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_EXPORT_ALL_DECLARATION_H
+#define ES2PANDA_IR_MODULE_EXPORT_ALL_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+class StringLiteral;
+
+class ExportAllDeclaration : public Statement {
+public:
+    explicit ExportAllDeclaration(StringLiteral *source, Identifier *exported)
+        : Statement(AstNodeType::EXPORT_ALL_DECLARATION), source_(source), exported_(exported)
+    {
+    }
+
+    const StringLiteral *Source() const
+    {
+        return source_;
+    }
+
+    const Identifier *Exported() const
+    {
+        return exported_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    StringLiteral *source_;
+    Identifier *exported_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/module/exportDefaultDeclaration.cpp b/es2panda/ir/module/exportDefaultDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..92dc53cd961585dca5f8dbf66d08b485ca81155f
--- /dev/null
+++ b/es2panda/ir/module/exportDefaultDeclaration.cpp
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "exportDefaultDeclaration.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void ExportDefaultDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(decl_);
+}
+
+void ExportDefaultDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add(
+        {{"type", IsExportEquals() ? "TSExportAssignment" : "ExportDefaultDeclaration"}, {"declaration", decl_}});
+}
+
+void ExportDefaultDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    decl_->Compile(pg);
+    pg->StoreModuleVar(this, "default");
+}
+
+checker::Type *ExportDefaultDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/exportDefaultDeclaration.h b/es2panda/ir/module/exportDefaultDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..997a8e89fb31d7d8fa4f1b9a6813a4f27ddf34c1
--- /dev/null
+++ b/es2panda/ir/module/exportDefaultDeclaration.h
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_EXPORT_DEFAULT_DECLARATION_H
+#define ES2PANDA_IR_MODULE_EXPORT_DEFAULT_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ExportDefaultDeclaration : public Statement {
+public:
+    explicit ExportDefaultDeclaration(AstNode *decl, bool exportEquals)
+        : Statement(AstNodeType::EXPORT_DEFAULT_DECLARATION), decl_(decl), exportEquals_(exportEquals)
+    {
+    }
+
+    const AstNode *Decl() const
+    {
+        return decl_;
+    }
+
+    bool IsExportEquals() const
+    {
+        return exportEquals_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    AstNode *decl_;
+    bool exportEquals_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/module/exportNamedDeclaration.cpp b/es2panda/ir/module/exportNamedDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..62b9db7c68296f460b6aa4e5c408a773b9f32752
--- /dev/null
+++ b/es2panda/ir/module/exportNamedDeclaration.cpp
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "exportNamedDeclaration.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/module/exportSpecifier.h>
+
+namespace panda::es2panda::ir {
+
+void ExportNamedDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    if (decl_) {
+        cb(decl_);
+    } else {
+        if (source_) {
+            cb(source_);
+        }
+
+        for (auto *it : specifiers_) {
+            cb(it);
+        }
+    }
+}
+
+void ExportNamedDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ExportNamedDeclaration"},
+                 {"declaration", AstDumper::Nullable(decl_)},
+                 {"source", AstDumper::Nullable(source_)},
+                 {"specifiers", specifiers_}});
+}
+
+void ExportNamedDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    if (!decl_) {
+        return;
+    }
+
+    decl_->Compile(pg);
+}
+
+checker::Type *ExportNamedDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/exportNamedDeclaration.h b/es2panda/ir/module/exportNamedDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d01116149f16317382d61c6fc3457f3ae192740
--- /dev/null
+++ b/es2panda/ir/module/exportNamedDeclaration.h
@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_EXPORT_DECLARATION_H
+#define ES2PANDA_IR_MODULE_EXPORT_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class StringLiteral;
+class ExportSpecifier;
+
+class ExportNamedDeclaration : public Statement {
+public:
+    explicit ExportNamedDeclaration(StringLiteral *source, ArenaVector<ExportSpecifier *> &&specifiers)
+        : Statement(AstNodeType::EXPORT_NAMED_DECLARATION),
+          source_(source),
+          decl_(nullptr),
+          specifiers_(std::move(specifiers))
+    {
+    }
+
+    explicit ExportNamedDeclaration(Statement *decl, ArenaVector<ExportSpecifier *> &&specifiers)
+        : Statement(AstNodeType::EXPORT_NAMED_DECLARATION),
+          source_(nullptr),
+          decl_(decl),
+          specifiers_(std::move(specifiers))
+    {
+    }
+
+    const Statement *Decl() const
+    {
+        return decl_;
+    }
+
+    const StringLiteral *Source() const
+    {
+        return source_;
+    }
+
+    const ArenaVector<ExportSpecifier *> &Specifiers() const
+    {
+        return specifiers_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    StringLiteral *source_;
+    Statement *decl_;
+    ArenaVector<ExportSpecifier *> specifiers_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/module/exportSpecifier.cpp b/es2panda/ir/module/exportSpecifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39710daf39a1ec03459b1c62eb50520aab30d36f
--- /dev/null
+++ b/es2panda/ir/module/exportSpecifier.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "exportSpecifier.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void ExportSpecifier::Iterate(const NodeTraverser &cb) const
+{
+    cb(local_);
+    cb(exported_);
+}
+
+void ExportSpecifier::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ExportSpecifier"}, {"local", local_}, {"exported", exported_}});
+}
+
+void ExportSpecifier::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ExportSpecifier::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/exportSpecifier.h b/es2panda/ir/module/exportSpecifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..d160f7087538a785d04bd1c51213f45e79d5298d
--- /dev/null
+++ b/es2panda/ir/module/exportSpecifier.h
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_EXPORT_SPECIFIER_H
+#define ES2PANDA_IR_MODULE_EXPORT_SPECIFIER_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+
+class ExportSpecifier : public Statement {
+public:
+    explicit ExportSpecifier(Identifier *local, Identifier *exported)
+        : Statement(AstNodeType::EXPORT_SPECIFIER), local_(local), exported_(exported)
+    {
+    }
+
+    const Identifier *Local() const
+    {
+        return local_;
+    }
+
+    const Identifier *Exported() const
+    {
+        return exported_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Identifier *local_;
+    Identifier *exported_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/module/importDeclaration.cpp b/es2panda/ir/module/importDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad120eb007f2a16c7e1bd9c3f1356149619c6cef
--- /dev/null
+++ b/es2panda/ir/module/importDeclaration.cpp
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "importDeclaration.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/literals/stringLiteral.h>
+
+namespace panda::es2panda::ir {
+
+void ImportDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(source_);
+
+    for (auto *it : specifiers_) {
+        cb(it);
+    }
+}
+
+void ImportDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ImportDeclaration"}, {"source", source_}, {"specifiers", specifiers_}});
+}
+
+void ImportDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ImportDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/importDeclaration.h b/es2panda/ir/module/importDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..6407fb47e4ffc257a1b250f1f22bf138cf9b3397
--- /dev/null
+++ b/es2panda/ir/module/importDeclaration.h
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_IMPORT_DECLARATION_H
+#define ES2PANDA_IR_MODULE_IMPORT_DECLARATION_H
+
+#include <ir/statement.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class StringLiteral;
+
+class ImportDeclaration : public Statement {
+public:
+    explicit ImportDeclaration(StringLiteral *source, ArenaVector<AstNode *> &&specifiers)
+        : Statement(AstNodeType::IMPORT_DECLARATION), source_(source), specifiers_(std::move(specifiers))
+    {
+    }
+
+    const StringLiteral *Source() const
+    {
+        return source_;
+    }
+
+    const ArenaVector<AstNode *> &Specifiers() const
+    {
+        return specifiers_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    StringLiteral *source_;
+    ArenaVector<AstNode *> specifiers_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/module/importDefaultSpecifier.cpp b/es2panda/ir/module/importDefaultSpecifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cea1de1cbaeaf9f21ece7f7d6e89d994ffa3aaea
--- /dev/null
+++ b/es2panda/ir/module/importDefaultSpecifier.cpp
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "importDefaultSpecifier.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void ImportDefaultSpecifier::Iterate(const NodeTraverser &cb) const
+{
+    cb(local_);
+}
+
+void ImportDefaultSpecifier::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ImportDefaultSpecifier"}, {"local", local_}});
+}
+
+void ImportDefaultSpecifier::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ImportDefaultSpecifier::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/importDefaultSpecifier.h b/es2panda/ir/module/importDefaultSpecifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..c38d4a55739878a8bba375422057c6db4ed5d297
--- /dev/null
+++ b/es2panda/ir/module/importDefaultSpecifier.h
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_IMPORT_DEFAULT_SPECIFIER_H
+#define ES2PANDA_IR_MODULE_IMPORT_DEFAULT_SPECIFIER_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+
+class ImportDefaultSpecifier : public Statement {
+public:
+    explicit ImportDefaultSpecifier(Identifier *local) : Statement(AstNodeType::IMPORT_DEFAULT_SPECIFIER), local_(local)
+    {
+    }
+
+    const Identifier *Local() const
+    {
+        return local_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Identifier *local_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/module/importNamespaceSpecifier.cpp b/es2panda/ir/module/importNamespaceSpecifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a7ee3daa41268596e2e987b3a139a87db550b015
--- /dev/null
+++ b/es2panda/ir/module/importNamespaceSpecifier.cpp
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "importNamespaceSpecifier.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void ImportNamespaceSpecifier::Iterate(const NodeTraverser &cb) const
+{
+    cb(local_);
+}
+
+void ImportNamespaceSpecifier::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ImportNamespaceSpecifier"}, {"local", local_}});
+}
+
+void ImportNamespaceSpecifier::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ImportNamespaceSpecifier::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/importNamespaceSpecifier.h b/es2panda/ir/module/importNamespaceSpecifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc753f85e249cc4c6983a4a9ffd55b80864a6812
--- /dev/null
+++ b/es2panda/ir/module/importNamespaceSpecifier.h
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_IMPORT_NAMESPACE_SPECIFIER_H
+#define ES2PANDA_IR_MODULE_IMPORT_NAMESPACE_SPECIFIER_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+
+class ImportNamespaceSpecifier : public Statement {
+public:
+    explicit ImportNamespaceSpecifier(Identifier *local)
+        : Statement(AstNodeType::IMPORT_NAMESPACE_SPECIFIER), local_(local)
+    {
+    }
+
+    const Identifier *Local() const
+    {
+        return local_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Identifier *local_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/module/importSpecifier.cpp b/es2panda/ir/module/importSpecifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58ec2ee587115eccad2ea88eaac633ff43636063
--- /dev/null
+++ b/es2panda/ir/module/importSpecifier.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "importSpecifier.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void ImportSpecifier::Iterate(const NodeTraverser &cb) const
+{
+    cb(local_);
+    cb(imported_);
+}
+
+void ImportSpecifier::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ImportSpecifier"}, {"local", local_}, {"imported", imported_}});
+}
+
+void ImportSpecifier::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *ImportSpecifier::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/module/importSpecifier.h b/es2panda/ir/module/importSpecifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..6347067522bbaeda6474d00d0d8a4207cdfb4cab
--- /dev/null
+++ b/es2panda/ir/module/importSpecifier.h
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_MODULE_AST_IMPORT_SPECIFIER_H
+#define ES2PANDA_IR_MODULE_AST_IMPORT_SPECIFIER_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+
+class ImportSpecifier : public Statement {
+public:
+    explicit ImportSpecifier(Identifier *imported, Identifier *local)
+        : Statement(AstNodeType::IMPORT_SPECIFIER), imported_(imported), local_(local)
+    {
+    }
+
+    const Identifier *Imported() const
+    {
+        return imported_;
+    }
+
+    const Identifier *Local() const
+    {
+        return local_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Identifier *imported_;
+    Identifier *local_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/opcodeMap.h b/es2panda/ir/opcodeMap.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6073bcb99624014b88267f82fd8209eca68440d
--- /dev/null
+++ b/es2panda/ir/opcodeMap.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_GEN_OPCODE_MAP_H
+#define ES2PANDA_COMPILER_GEN_OPCODE_MAP_H
+
+#include <assembly-ins.h>
+
+namespace panda::es2panda::debuginfo {
+
+const char *pandaInsToString(const panda::pandasm::Ins &ins);
+
+}  // namespace panda::es2panda::debuginfo
+
+#endif  // GEN_OPCODE_MAP_H
diff --git a/es2panda/ir/statement.cpp b/es2panda/ir/statement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0df4d58e3d7b5dbe83c5c5a0580bf397f86591df
--- /dev/null
+++ b/es2panda/ir/statement.cpp
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "statement.h"
+
+namespace panda::es2panda::ir {
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statement.h b/es2panda/ir/statement.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9493feb7f42d6f3fc7da981e7e8fb77301330d3
--- /dev/null
+++ b/es2panda/ir/statement.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_H
+
+#include <ir/astNode.h>
+
+namespace panda::es2panda::ir {
+
+class Statement : public AstNode {
+public:
+    bool IsStatement() const override
+    {
+        return true;
+    }
+
+protected:
+    explicit Statement(AstNodeType type) : AstNode(type) {}
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/blockStatement.cpp b/es2panda/ir/statements/blockStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e9c49907da3131fa9a19eb2ab53e9206da54e547
--- /dev/null
+++ b/es2panda/ir/statements/blockStatement.cpp
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "blockStatement.h"
+
+#include <binder/scope.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void BlockStatement::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : statements_) {
+        cb(it);
+    }
+}
+
+void BlockStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", IsProgram() ? "Program" : "BlockStatement"}, {"statements", statements_}});
+}
+
+void BlockStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LocalRegScope lrs(pg, scope_);
+
+    for (const auto *it : statements_) {
+        it->Compile(pg);
+    }
+}
+
+checker::Type *BlockStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, scope_);
+
+    for (const auto *it : statements_) {
+        it->Check(checker);
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/blockStatement.h b/es2panda/ir/statements/blockStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..53e4369f01a6b6319a6d8d0176a16b144b30895a
--- /dev/null
+++ b/es2panda/ir/statements/blockStatement.h
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_BLOCK_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_BLOCK_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class BlockStatement : public Statement {
+public:
+    explicit BlockStatement(binder::Scope *scope, ArenaVector<Statement *> &&statementList)
+        : Statement(AstNodeType::BLOCK_STATEMENT), scope_(scope), statements_(std::move(statementList))
+    {
+    }
+
+    binder::Scope *Scope() const
+    {
+        return scope_;
+    }
+
+    const ArenaVector<Statement *> &Statements() const
+    {
+        return statements_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    binder::Scope *scope_;
+    ArenaVector<Statement *> statements_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/breakStatement.cpp b/es2panda/ir/statements/breakStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..75fc07a23fc6bd378fd777903ed21b2fb5df848e
--- /dev/null
+++ b/es2panda/ir/statements/breakStatement.cpp
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "breakStatement.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void BreakStatement::Iterate(const NodeTraverser &cb) const
+{
+    if (ident_) {
+        cb(ident_);
+    }
+}
+
+void BreakStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "BreakStatement"}, {"label", AstDumper::Nullable(ident_)}});
+}
+
+void BreakStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::Label *target = pg->ControlFlowChangeBreak(ident_);
+    pg->Branch(this, target);
+}
+
+checker::Type *BreakStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/breakStatement.h b/es2panda/ir/statements/breakStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0fa68ba55194c929aed634cc64ac8120a035f21
--- /dev/null
+++ b/es2panda/ir/statements/breakStatement.h
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_BREAK_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_BREAK_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+
+class BreakStatement : public Statement {
+public:
+    explicit BreakStatement() : Statement(AstNodeType::BREAK_STATEMENT) {}
+    explicit BreakStatement(Identifier *ident) : Statement(AstNodeType::BREAK_STATEMENT), ident_(ident) {}
+
+    const Identifier *Ident() const
+    {
+        return ident_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Identifier *ident_ {};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/classDeclaration.cpp b/es2panda/ir/statements/classDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0964fcf99a882561282f3682c1a5e4a390d6cd70
--- /dev/null
+++ b/es2panda/ir/statements/classDeclaration.cpp
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "classDeclaration.h"
+
+#include <compiler/base/lreference.h>
+#include <ir/astDump.h>
+#include <ir/base/classDefinition.h>
+#include <ir/base/decorator.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void ClassDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(def_);
+
+    for (auto *it : decorators_) {
+        cb(it);
+    }
+}
+
+void ClassDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ClassDeclaration"}, {"definition", def_}, {"decorators", decorators_}});
+}
+
+void ClassDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    auto lref = compiler::LReference::CreateLRef(pg, def_->Ident(), true);
+    def_->Compile(pg);
+    lref.SetValue();
+}
+
+checker::Type *ClassDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/classDeclaration.h b/es2panda/ir/statements/classDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a42cf09d673adae518b7bdfa4f9b5f871b1e2c6
--- /dev/null
+++ b/es2panda/ir/statements/classDeclaration.h
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_CLASS_DECLARATION_H
+#define ES2PANDA_IR_STATEMENT_CLASS_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ClassDeclaration : public Statement {
+public:
+    explicit ClassDeclaration(ClassDefinition *def, ArenaVector<Decorator *> &&decorators)
+        : Statement(AstNodeType::CLASS_DECLARATION), def_(def), decorators_(std::move(decorators))
+    {
+    }
+
+    const ClassDefinition *Definition() const
+    {
+        return def_;
+    }
+
+    const ArenaVector<Decorator *> &Decorators() const
+    {
+        return decorators_;
+    }
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ClassDefinition *def_;
+    ArenaVector<Decorator *> decorators_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/continueStatement.cpp b/es2panda/ir/statements/continueStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9f27358ffbdc47a66faa1d51eba90393b8fd3945
--- /dev/null
+++ b/es2panda/ir/statements/continueStatement.cpp
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "continueStatement.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void ContinueStatement::Iterate(const NodeTraverser &cb) const
+{
+    if (ident_) {
+        cb(ident_);
+    }
+}
+
+void ContinueStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ContinueStatement"}, {"label", AstDumper::Nullable(ident_)}});
+}
+
+void ContinueStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::Label *target = pg->ControlFlowChangeContinue(ident_);
+    pg->Branch(this, target);
+}
+
+checker::Type *ContinueStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/continueStatement.h b/es2panda/ir/statements/continueStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b5d2357f836666fa2e6c08c8554ff710ff00ae6
--- /dev/null
+++ b/es2panda/ir/statements/continueStatement.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_H_CONTINUE_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_H_CONTINUE_STATEMENT_H
+
+#include <ir/statement.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ContinueStatement : public Statement {
+public:
+    explicit ContinueStatement() : Statement(AstNodeType::CONTINUE_STATEMENT) {}
+    explicit ContinueStatement(Identifier *ident) : Statement(AstNodeType::CONTINUE_STATEMENT), ident_(ident) {}
+
+    const Identifier *Ident() const
+    {
+        return ident_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Identifier *ident_ {};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/debuggerStatement.cpp b/es2panda/ir/statements/debuggerStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a72d12075d4a7b3f509aa1b4c8c9bf9b8d410157
--- /dev/null
+++ b/es2panda/ir/statements/debuggerStatement.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "debuggerStatement.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void DebuggerStatement::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void DebuggerStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "DebuggerStatement"}});
+}
+
+void DebuggerStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *DebuggerStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/debuggerStatement.h b/es2panda/ir/statements/debuggerStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..07c3352e09bfee0df88cb408289b038a12769fdb
--- /dev/null
+++ b/es2panda/ir/statements/debuggerStatement.h
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_H_DEBUGGER_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_H_DEBUGGER_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class DebuggerStatement : public Statement {
+public:
+    explicit DebuggerStatement() : Statement(AstNodeType::DEBUGGER_STATEMENT) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/doWhileStatement.cpp b/es2panda/ir/statements/doWhileStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba7e4250cabaae871f7d16fcd25e0aa910c12547
--- /dev/null
+++ b/es2panda/ir/statements/doWhileStatement.cpp
@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "doWhileStatement.h"
+
+#include <binder/scope.h>
+#include <compiler/base/condition.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void DoWhileStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(body_);
+    cb(test_);
+}
+
+void DoWhileStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "DoWhileStatement"}, {"body", body_}, {"test", test_}});
+}
+
+void DoWhileStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    auto *startLabel = pg->AllocLabel();
+    compiler::LabelTarget labelTarget(pg);
+
+    pg->SetLabel(this, startLabel);
+
+    {
+        compiler::LocalRegScope regScope(pg, scope_);
+        compiler::LabelContext labelCtx(pg, labelTarget);
+        body_->Compile(pg);
+    }
+
+    pg->SetLabel(this, labelTarget.ContinueTarget());
+    compiler::Condition::Compile(pg, this->Test(), labelTarget.BreakTarget());
+
+    pg->Branch(this, startLabel);
+    pg->SetLabel(this, labelTarget.BreakTarget());
+}
+
+checker::Type *DoWhileStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, scope_);
+
+    checker::Type *testType = test_->Check(checker);
+    checker->CheckTruthinessOfType(testType, this->Start());
+    body_->Check(checker);
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/doWhileStatement.h b/es2panda/ir/statements/doWhileStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5e5812ed9ec044c32c63b59df2e2e7ccfb15ae0
--- /dev/null
+++ b/es2panda/ir/statements/doWhileStatement.h
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_H_DO_WHILE_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_H_DO_WHILE_STATEMENT_H
+
+#include <ir/statements/loopStatement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class LoopScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class DoWhileStatement : public LoopStatement {
+public:
+    explicit DoWhileStatement(binder::LoopScope *scope, Statement *body, Expression *test)
+        : LoopStatement(AstNodeType::DO_WHILE_STATEMENT, scope), body_(body), test_(test)
+    {
+    }
+
+    const Statement *Body() const
+    {
+        return body_;
+    }
+
+    Statement *Body()
+    {
+        return body_;
+    }
+
+    const Expression *Test() const
+    {
+        return test_;
+    }
+
+    Expression *Test()
+    {
+        return test_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Statement *body_;
+    Expression *test_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/emptyStatement.cpp b/es2panda/ir/statements/emptyStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad7d07f66aeb9fad1c6284289431216cc6a2e89a
--- /dev/null
+++ b/es2panda/ir/statements/emptyStatement.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "emptyStatement.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void EmptyStatement::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void EmptyStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "EmptyStatement"}});
+}
+
+void EmptyStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *EmptyStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/emptyStatement.h b/es2panda/ir/statements/emptyStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..de5e9b90ee89c7fc2f9b3d0275a0a2adb602edfd
--- /dev/null
+++ b/es2panda/ir/statements/emptyStatement.h
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_EMPTY_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_EMPTY_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class EmptyStatement : public Statement {
+public:
+    explicit EmptyStatement() : Statement(AstNodeType::EMPTY_STATEMENT) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/expressionStatement.cpp b/es2panda/ir/statements/expressionStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e09ebfc6d42ec1c079b88da634d277e364716712
--- /dev/null
+++ b/es2panda/ir/statements/expressionStatement.cpp
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "expressionStatement.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void ExpressionStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(expression_);
+}
+
+void ExpressionStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ExpressionStatement"}, {"expression", expression_}});
+}
+
+void ExpressionStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    expression_->Compile(pg);
+}
+
+checker::Type *ExpressionStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/expressionStatement.h b/es2panda/ir/statements/expressionStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa319c7ac7e0be5ea3179f70e067d4f483d68d77
--- /dev/null
+++ b/es2panda/ir/statements/expressionStatement.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_EXPRESSION_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_EXPRESSION_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class ExpressionStatement : public Statement {
+public:
+    explicit ExpressionStatement(Expression *expr) : Statement(AstNodeType::EXPRESSION_STATEMENT), expression_(expr) {}
+
+    const Expression *GetExpression() const
+    {
+        return expression_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expression_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/forInStatement.cpp b/es2panda/ir/statements/forInStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e70fd6f324fd4dc9eadbcf66be95e1fd0f427cea
--- /dev/null
+++ b/es2panda/ir/statements/forInStatement.cpp
@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "forInStatement.h"
+
+#include <binder/scope.h>
+#include <compiler/base/lreference.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void ForInStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(left_);
+    cb(right_);
+    cb(body_);
+}
+
+void ForInStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ForInStatement"}, {"left", left_}, {"right", right_}, {"body", body_}});
+}
+
+void ForInStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LabelTarget labelTarget(pg);
+
+    compiler::RegScope rs(pg);
+    compiler::VReg iter = pg->AllocReg();
+    compiler::VReg propName = pg->AllocReg();
+
+    // create enumerator
+    right_->Compile(pg);
+    pg->GetPropIterator(this);
+    pg->StoreAccumulator(this, iter);
+
+    pg->SetLabel(this, labelTarget.ContinueTarget());
+
+    // get next prop of enumerator
+    pg->GetNextPropName(this, iter);
+    pg->StoreAccumulator(this, propName);
+    pg->BranchIfUndefined(this, labelTarget.BreakTarget());
+
+    compiler::LocalRegScope declRegScope(pg, scope_->DeclScope()->InitScope());
+    auto lref = compiler::LReference::CreateLRef(pg, left_, false);
+    pg->LoadAccumulator(this, propName);
+    lref.SetValue();
+
+    compiler::LoopEnvScope declEnvScope(pg, scope_->DeclScope());
+
+    {
+        compiler::LoopEnvScope envScope(pg, scope_, labelTarget);
+        body_->Compile(pg);
+    }
+
+    pg->Branch(this, labelTarget.ContinueTarget());
+    pg->SetLabel(this, labelTarget.BreakTarget());
+}
+
+checker::Type *ForInStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/forInStatement.h b/es2panda/ir/statements/forInStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6701d87dac806f3dedf7aafeb0ede5212574af9
--- /dev/null
+++ b/es2panda/ir/statements/forInStatement.h
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_FOR_IN_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_FOR_IN_STATEMENT_H
+
+#include <ir/statements/loopStatement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class LoopScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class ForInStatement : public LoopStatement {
+public:
+    explicit ForInStatement(binder::LoopScope *scope, AstNode *left, Expression *right, Statement *body)
+        : LoopStatement(AstNodeType::FOR_IN_STATEMENT, scope), left_(left), right_(right), body_(body)
+    {
+    }
+
+    AstNode *Left()
+    {
+        return left_;
+    }
+
+    const AstNode *Left() const
+    {
+        return left_;
+    }
+
+    Expression *Right()
+    {
+        return right_;
+    }
+
+    const Expression *Right() const
+    {
+        return right_;
+    }
+
+    Statement *Body()
+    {
+        return body_;
+    }
+
+    const Statement *Body() const
+    {
+        return body_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    AstNode *left_;
+    Expression *right_;
+    Statement *body_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/forOfStatement.cpp b/es2panda/ir/statements/forOfStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..241a63e7c03751ed8cf2a48707b8c838410b3838
--- /dev/null
+++ b/es2panda/ir/statements/forOfStatement.cpp
@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "forOfStatement.h"
+
+#include <binder/scope.h>
+#include <compiler/base/iterators.h>
+#include <compiler/base/lreference.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void ForOfStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(left_);
+    cb(right_);
+    cb(body_);
+}
+
+void ForOfStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ForOfStatement"}, {"await", isAwait_}, {"left", left_}, {"right", right_}, {"body", body_}});
+}
+
+void ForOfStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LocalRegScope declRegScope(pg, scope_->DeclScope()->InitScope());
+
+    right_->Compile(pg);
+
+    compiler::LabelTarget labelTarget(pg);
+    auto iterator_type = isAwait_ ? compiler::IteratorType::ASYNC : compiler::IteratorType::SYNC;
+    compiler::Iterator iterator(pg, this, iterator_type);
+
+    pg->SetLabel(this, labelTarget.ContinueTarget());
+
+    iterator.Next();
+    iterator.Complete();
+    pg->BranchIfTrue(this, labelTarget.BreakTarget());
+
+    compiler::VReg value = pg->AllocReg();
+    iterator.Value();
+    pg->StoreAccumulator(this, value);
+
+    auto lref = compiler::LReference::CreateLRef(pg, left_, false);
+
+    {
+        compiler::IteratorContext forOfCtx(pg, iterator, labelTarget);
+        pg->LoadAccumulator(this, value);
+        lref.SetValue();
+
+        compiler::LoopEnvScope declEnvScope(pg, scope_->DeclScope());
+        compiler::LoopEnvScope envScope(pg, scope_, {});
+        body_->Compile(pg);
+    }
+
+    pg->Branch(this, labelTarget.ContinueTarget());
+    pg->SetLabel(this, labelTarget.BreakTarget());
+}
+
+checker::Type *ForOfStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/forOfStatement.h b/es2panda/ir/statements/forOfStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..c48b5ea9be8c7b05f16995c32ef6f75f0c370575
--- /dev/null
+++ b/es2panda/ir/statements/forOfStatement.h
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_FOR_OF_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_FOR_OF_STATEMENT_H
+
+#include <ir/statements/loopStatement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class LoopScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class ForOfStatement : public LoopStatement {
+public:
+    explicit ForOfStatement(binder::LoopScope *scope, AstNode *left, Expression *right, Statement *body, bool isAwait)
+        : LoopStatement(AstNodeType::FOR_OF_STATEMENT, scope),
+          left_(left),
+          right_(right),
+          body_(body),
+          isAwait_(isAwait)
+    {
+    }
+
+    AstNode *Left()
+    {
+        return left_;
+    }
+
+    const AstNode *Left() const
+    {
+        return left_;
+    }
+
+    Expression *Right()
+    {
+        return right_;
+    }
+
+    const Expression *Right() const
+    {
+        return right_;
+    }
+
+    Statement *Body()
+    {
+        return body_;
+    }
+
+    const Statement *Body() const
+    {
+        return body_;
+    }
+
+    bool IsAwait() const
+    {
+        return isAwait_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    AstNode *left_;
+    Expression *right_;
+    Statement *body_;
+    bool isAwait_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/forUpdateStatement.cpp b/es2panda/ir/statements/forUpdateStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7b6abd3b0c903c7b9dd1d5de07b41ff145842235
--- /dev/null
+++ b/es2panda/ir/statements/forUpdateStatement.cpp
@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "forUpdateStatement.h"
+
+#include <binder/scope.h>
+#include <compiler/base/condition.h>
+#include <compiler/base/lreference.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/dynamicContext.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void ForUpdateStatement::Iterate(const NodeTraverser &cb) const
+{
+    if (init_) {
+        cb(init_);
+    }
+    if (test_) {
+        cb(test_);
+    }
+    if (update_) {
+        cb(update_);
+    }
+
+    cb(body_);
+}
+
+void ForUpdateStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ForUpdateStatement"},
+                 {"init", AstDumper::Nullable(init_)},
+                 {"test", AstDumper::Nullable(test_)},
+                 {"update", AstDumper::Nullable(update_)},
+                 {"body", body_}});
+}
+
+void ForUpdateStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LocalRegScope declRegScope(pg, scope_->DeclScope()->InitScope());
+
+    if (init_) {
+        ASSERT(init_->IsVariableDeclaration() || init_->IsExpression());
+        init_->Compile(pg);
+    }
+
+    auto *startLabel = pg->AllocLabel();
+    compiler::LabelTarget labelTarget(pg);
+
+    compiler::LoopEnvScope declEnvScope(pg, scope_->DeclScope());
+    compiler::LoopEnvScope envScope(pg, labelTarget, scope_);
+    pg->SetLabel(this, startLabel);
+
+    {
+        compiler::LocalRegScope regScope(pg, scope_);
+
+        if (test_) {
+            compiler::Condition::Compile(pg, test_, labelTarget.BreakTarget());
+        }
+
+        body_->Compile(pg);
+        pg->SetLabel(this, labelTarget.ContinueTarget());
+        envScope.CopyPetIterationCtx();
+    }
+
+    if (update_) {
+        update_->Compile(pg);
+    }
+
+    pg->Branch(this, startLabel);
+    pg->SetLabel(this, labelTarget.BreakTarget());
+}
+
+checker::Type *ForUpdateStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, scope_);
+
+    if (init_) {
+        init_->Check(checker);
+    }
+
+    if (test_) {
+        checker::Type *testType = test_->Check(checker);
+        checker->CheckTruthinessOfType(testType, Start());
+    }
+
+    if (update_) {
+        update_->Check(checker);
+    }
+
+    body_->Check(checker);
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/forUpdateStatement.h b/es2panda/ir/statements/forUpdateStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..a607f222662727e9c5b23cee2e4a57596797680d
--- /dev/null
+++ b/es2panda/ir/statements/forUpdateStatement.h
@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_FOR_UPDATE_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_FOR_UPDATE_STATEMENT_H
+
+#include <ir/statements/loopStatement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class LoopScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class ForUpdateStatement : public LoopStatement {
+public:
+    explicit ForUpdateStatement(binder::LoopScope *scope, AstNode *init, Expression *test, Expression *update,
+                                Statement *body)
+        : LoopStatement(AstNodeType::FOR_UPDATE_STATEMENT, scope),
+          init_(init),
+          test_(test),
+          update_(update),
+          body_(body)
+    {
+    }
+
+    AstNode *Init()
+    {
+        return init_;
+    }
+
+    const AstNode *Init() const
+    {
+        return init_;
+    }
+
+    Expression *Test()
+    {
+        return test_;
+    }
+
+    const Expression *Test() const
+    {
+        return test_;
+    }
+
+    Expression *Update()
+    {
+        return update_;
+    }
+
+    const Expression *Update() const
+    {
+        return update_;
+    }
+
+    Statement *Body()
+    {
+        return body_;
+    }
+
+    const Statement *Body() const
+    {
+        return body_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    AstNode *init_;
+    Expression *test_;
+    Expression *update_;
+    Statement *body_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/functionDeclaration.cpp b/es2panda/ir/statements/functionDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e07fe784ab2e4eaebd2d8525a3122ad13a82e90e
--- /dev/null
+++ b/es2panda/ir/statements/functionDeclaration.cpp
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "functionDeclaration.h"
+
+#include <binder/variable.h>
+#include <binder/scope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void FunctionDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(func_);
+}
+
+void FunctionDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", func_->IsOverload() ? "TSDeclareFunction" : "FunctionDeclaration"}, {"function", func_}});
+}
+
+void FunctionDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *FunctionDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, func_->Scope());
+
+    if (func_->IsOverload()) {
+        return nullptr;
+    }
+
+    const util::StringView &funcName = func_->Id()->Name();
+    binder::ScopeFindResult result = checker->Scope()->Find(funcName);
+    ASSERT(result.variable);
+
+    if (!result.variable->TsType()) {
+        checker->InferFunctionDeclarationType(result.variable->Declaration()->AsFunctionDecl(), result.variable);
+    }
+
+    func_->Body()->Check(checker);
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/functionDeclaration.h b/es2panda/ir/statements/functionDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0eafe17eaf152314b8795c83d82bd84576d2b14
--- /dev/null
+++ b/es2panda/ir/statements/functionDeclaration.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_FUNCTION_DECLARATION_H
+#define ES2PANDA_IR_STATEMENT_FUNCTION_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ScriptFunction;
+
+class FunctionDeclaration : public Statement {
+public:
+    explicit FunctionDeclaration(ScriptFunction *func) : Statement(AstNodeType::FUNCTION_DECLARATION), func_(func) {}
+
+    const ScriptFunction *Function() const
+    {
+        return func_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ScriptFunction *func_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/ifStatement.cpp b/es2panda/ir/statements/ifStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..34944a0dcdce0a1657738f2018a09d059ebf81e9
--- /dev/null
+++ b/es2panda/ir/statements/ifStatement.cpp
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ifStatement.h"
+
+#include <compiler/base/condition.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void IfStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(test_);
+    cb(consequent_);
+
+    if (alternate_) {
+        cb(alternate_);
+    }
+}
+
+void IfStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "IfStatement"},
+                 {"test", test_},
+                 {"consequent", consequent_},
+                 {"alternate", AstDumper::Nullable(alternate_)}});
+}
+
+void IfStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    auto *consequentEnd = pg->AllocLabel();
+    compiler::Label *statementEnd = consequentEnd;
+
+    compiler::Condition::Compile(pg, test_, consequentEnd);
+    consequent_->Compile(pg);
+
+    if (alternate_) {
+        statementEnd = pg->AllocLabel();
+        pg->Branch(pg->Insns().back()->Node(), statementEnd);
+
+        pg->SetLabel(this, consequentEnd);
+        alternate_->Compile(pg);
+    }
+
+    pg->SetLabel(this, statementEnd);
+}
+
+checker::Type *IfStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::Type *testType = test_->Check(checker);
+    checker->CheckTruthinessOfType(testType, Start());
+    checker->CheckTestingKnownTruthyCallableOrAwaitableType(test_, testType, consequent_);
+
+    consequent_->Check(checker);
+
+    if (alternate_) {
+        alternate_->Check(checker);
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/ifStatement.h b/es2panda/ir/statements/ifStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..eca6a401a89a506733c66fb34ef079e9dd58ecec
--- /dev/null
+++ b/es2panda/ir/statements/ifStatement.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_IF_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_IF_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class IfStatement : public Statement {
+public:
+    explicit IfStatement(Expression *test, Statement *consequent, Statement *alternate)
+        : Statement(AstNodeType::IF_STATEMENT), test_(test), consequent_(consequent), alternate_(alternate)
+    {
+    }
+
+    const Expression *Test() const
+    {
+        return test_;
+    }
+
+    const Statement *Consequent() const
+    {
+        return consequent_;
+    }
+
+    const Statement *Alternate() const
+    {
+        return alternate_;
+    }
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Expression *test_;
+    Statement *consequent_;
+    Statement *alternate_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/labelledStatement.cpp b/es2panda/ir/statements/labelledStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a799e8e05c584bdf0456bca894c1e9a7fbb07cf6
--- /dev/null
+++ b/es2panda/ir/statements/labelledStatement.cpp
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "labelledStatement.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/core/labelTarget.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void LabelledStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(ident_);
+    cb(body_);
+}
+
+void LabelledStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "LabelledStatement"}, {"label", ident_}, {"body", body_}});
+}
+
+void LabelledStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LabelContext labelCtx(pg, this);
+    body_->Compile(pg);
+}
+
+checker::Type *LabelledStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/labelledStatement.h b/es2panda/ir/statements/labelledStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..e52c51793d814bf92ded2cc317c953971d77696a
--- /dev/null
+++ b/es2panda/ir/statements/labelledStatement.h
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_LABELLED_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_LABELLED_STATEMENT_H
+
+#include <ir/statement.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+
+class LabelledStatement : public Statement {
+public:
+    explicit LabelledStatement(Identifier *ident, Statement *body)
+        : Statement(AstNodeType::LABELLED_STATEMENT), ident_(ident), body_(body)
+    {
+    }
+
+    const Statement *Body() const
+    {
+        return body_;
+    }
+
+    const Identifier *Ident() const
+    {
+        return ident_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Identifier *ident_;
+    Statement *body_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/loopStatement.cpp b/es2panda/ir/statements/loopStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4a17cb926af2505c1c3fe3408ebdc607f4479157
--- /dev/null
+++ b/es2panda/ir/statements/loopStatement.cpp
@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "loopStatement.h"
+
+#include <binder/scope.h>
+
+namespace panda::es2panda::ir {
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/loopStatement.h b/es2panda/ir/statements/loopStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..f73979ef602f43d98c08d55bdda445e0d629800b
--- /dev/null
+++ b/es2panda/ir/statements/loopStatement.h
@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_LOOPSTATEMENT_H
+#define ES2PANDA_IR_STATEMENT_LOOPSTATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::binder {
+class LoopScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+class LoopStatement : public Statement {
+public:
+    binder::LoopScope *Scope() const
+    {
+        return scope_;
+    }
+
+    void Iterate([[maybe_unused]] const NodeTraverser &cb) const override
+    {
+        UNREACHABLE();
+    }
+
+    void Dump([[maybe_unused]] AstDumper *dumper) const override
+    {
+        UNREACHABLE();
+    }
+
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override
+    {
+        UNREACHABLE();
+    }
+
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override
+    {
+        UNREACHABLE();
+        return nullptr;
+    }
+
+protected:
+    explicit LoopStatement(AstNodeType type, binder::LoopScope *scope) : Statement(type), scope_(scope) {}
+
+    binder::LoopScope *scope_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/returnStatement.cpp b/es2panda/ir/statements/returnStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f9a8200699ca4efe0406937d35586df015292c40
--- /dev/null
+++ b/es2panda/ir/statements/returnStatement.cpp
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "returnStatement.h"
+
+#include <ir/base/methodDefinition.h>
+#include <ir/base/scriptFunction.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void ReturnStatement::Iterate(const NodeTraverser &cb) const
+{
+    if (argument_) {
+        cb(argument_);
+    }
+}
+
+void ReturnStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ReturnStatement"}, {"argument", AstDumper::Nullable(argument_)}});
+}
+
+void ReturnStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    if (argument_) {
+        argument_->Compile(pg);
+    } else {
+        pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+    }
+
+    if (pg->CheckControlFlowChange()) {
+        compiler::RegScope rs(pg);
+        compiler::VReg res = pg->AllocReg();
+
+        pg->StoreAccumulator(this, res);
+        pg->ControlFlowChangeBreak();
+        pg->LoadAccumulator(this, res);
+    }
+
+    if (argument_) {
+        pg->ValidateClassDirectReturn(this);
+        pg->DirectReturn(this);
+    } else {
+        pg->ImplicitReturn(this);
+    }
+}
+
+checker::Type *ReturnStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    const ir::AstNode *ancestor = checker::Checker::FindAncestorGivenByType(this, ir::AstNodeType::SCRIPT_FUNCTION);
+    ASSERT(ancestor && ancestor->IsScriptFunction());
+    const ir::ScriptFunction *containingFunc = ancestor->AsScriptFunction();
+
+    if (containingFunc->Parent()->Parent()->IsMethodDefinition()) {
+        const ir::MethodDefinition *containingClassMethod = containingFunc->Parent()->Parent()->AsMethodDefinition();
+        if (containingClassMethod->Kind() == ir::MethodDefinitionKind::SET) {
+            checker->ThrowTypeError("Setters cannot return a value", Start());
+        }
+    }
+
+    if (containingFunc->ReturnTypeAnnotation()) {
+        checker::Type *returnType = checker->GlobalUndefinedType();
+        checker::Type *funcReturnType = containingFunc->ReturnTypeAnnotation()->Check(checker);
+
+        if (argument_) {
+            if (checker->ElaborateElementwise(argument_, funcReturnType, Start())) {
+                return nullptr;
+            }
+
+            returnType = argument_->Check(checker);
+        }
+
+        checker->IsTypeAssignableTo(returnType, funcReturnType,
+                                    {"Type '", returnType, "' is not assignable to type '", funcReturnType, "'."},
+                                    Start());
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/returnStatement.h b/es2panda/ir/statements/returnStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..65e772940c6e16528de4bf5c8ee5493507b80e58
--- /dev/null
+++ b/es2panda/ir/statements/returnStatement.h
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_RETURN_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_RETURN_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class ReturnStatement : public Statement {
+public:
+    explicit ReturnStatement() : ReturnStatement(nullptr) {}
+    explicit ReturnStatement(Expression *argument) : Statement(AstNodeType::RETURN_STATEMENT), argument_(argument) {}
+
+    const Expression *Argument() const
+    {
+        return argument_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Expression *argument_ {};
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/switchCaseStatement.cpp b/es2panda/ir/statements/switchCaseStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2fd5c7866e9f41e3cca8a0adb212c6a5260a7ed
--- /dev/null
+++ b/es2panda/ir/statements/switchCaseStatement.cpp
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "switchCaseStatement.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void SwitchCaseStatement::Iterate(const NodeTraverser &cb) const
+{
+    if (test_) {
+        cb(test_);
+    }
+
+    for (auto *it : consequent_) {
+        cb(it);
+    }
+}
+
+void SwitchCaseStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "SwitchCase"}, {"test", AstDumper::Nullable(test_)}, {"consequent", consequent_}});
+}
+
+void SwitchCaseStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *SwitchCaseStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/switchCaseStatement.h b/es2panda/ir/statements/switchCaseStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb6a6f95f07d420254d589baa2468b0ad0aa88cd
--- /dev/null
+++ b/es2panda/ir/statements/switchCaseStatement.h
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_SWITCH_CASE_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_SWITCH_CASE_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class SwitchCaseStatement : public Statement {
+public:
+    explicit SwitchCaseStatement(Expression *test, ArenaVector<Statement *> &&consequent)
+        : Statement(AstNodeType::SWITCH_CASE_STATEMENT), test_(test), consequent_(std::move(consequent))
+    {
+    }
+
+    const Expression *Test() const
+    {
+        return test_;
+    }
+
+    const ArenaVector<Statement *> &Consequent() const
+    {
+        return consequent_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Expression *test_;
+    ArenaVector<Statement *> consequent_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/switchStatement.cpp b/es2panda/ir/statements/switchStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86ea76041aac9fdd2e73815af6df6709ba0dbdf9
--- /dev/null
+++ b/es2panda/ir/statements/switchStatement.cpp
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "switchStatement.h"
+
+#include <binder/scope.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/core/switchBuilder.h>
+#include <compiler/core/pandagen.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+#include <ir/statements/switchCaseStatement.h>
+
+namespace panda::es2panda::ir {
+
+void SwitchStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(discriminant_);
+
+    for (auto *it : cases_) {
+        cb(it);
+    }
+}
+
+void SwitchStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "SwitchStatement"}, {"discriminant", discriminant_}, {"cases", cases_}});
+}
+
+void SwitchStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LocalRegScope lrs(pg, scope_);
+    compiler::SwitchBuilder builder(pg, this);
+    compiler::VReg tag = pg->AllocReg();
+
+    builder.CompileTagOfSwitch(tag);
+    uint32_t defaultIndex = 0;
+
+    for (size_t i = 0; i < cases_.size(); i++) {
+        const auto *clause = cases_[i];
+
+        if (!clause->Test()) {
+            defaultIndex = i;
+            continue;
+        }
+
+        builder.JumpIfCase(tag, i);
+    }
+
+    if (defaultIndex > 0) {
+        builder.JumpToDefault(defaultIndex);
+    } else {
+        builder.Break();
+    }
+
+    for (size_t i = 0; i < cases_.size(); i++) {
+        builder.SetCaseTarget(i);
+        builder.CompileCaseStatements(i);
+    }
+}
+
+checker::Type *SwitchStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, scope_);
+
+    checker::Type *exprType = discriminant_->Check(checker);
+    bool exprIsLiteral = checker::Checker::IsLiteralType(exprType);
+
+    for (auto *it : cases_) {
+        if (it->Test()) {
+            checker::Type *caseType = it->Test()->Check(checker);
+            bool caseIsLiteral = checker::Checker::IsLiteralType(caseType);
+            checker::Type *comparedExprType = exprType;
+
+            if (!caseIsLiteral || !exprIsLiteral) {
+                caseType = caseIsLiteral ? checker->GetBaseTypeOfLiteralType(caseType) : caseType;
+                comparedExprType = checker->GetBaseTypeOfLiteralType(exprType);
+            }
+
+            if (!checker->IsTypeEqualityComparableTo(comparedExprType, caseType) &&
+                !checker->IsTypeComparableTo(caseType, comparedExprType)) {
+                checker->ThrowTypeError({"Type ", caseType, " is not comparable to type ", comparedExprType},
+                                        it->Test()->Start());
+            }
+        }
+
+        for (auto *caseStmt : it->Consequent()) {
+            caseStmt->Check(checker);
+        }
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/switchStatement.h b/es2panda/ir/statements/switchStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e85ce9b04ac56903ad8dc4b3776fadcc20fb44b
--- /dev/null
+++ b/es2panda/ir/statements/switchStatement.h
@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_SWITCH_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_SWITCH_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class LocalScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class Expression;
+class SwitchCaseStatement;
+
+class SwitchStatement : public Statement {
+public:
+    explicit SwitchStatement(binder::LocalScope *scope, Expression *discriminant,
+                             ArenaVector<SwitchCaseStatement *> &&cases)
+        : Statement(AstNodeType::SWITCH_STATEMENT), scope_(scope), discriminant_(discriminant), cases_(std::move(cases))
+    {
+    }
+
+    const Expression *Discriminant() const
+    {
+        return discriminant_;
+    }
+
+    const ArenaVector<SwitchCaseStatement *> &Cases() const
+    {
+        return cases_;
+    }
+
+    binder::LocalScope *Scope() const
+    {
+        return scope_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    binder::LocalScope *scope_;
+    Expression *discriminant_;
+    ArenaVector<SwitchCaseStatement *> cases_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/throwStatement.cpp b/es2panda/ir/statements/throwStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a17408337e61987a33f0fc9e265564bf482049e7
--- /dev/null
+++ b/es2panda/ir/statements/throwStatement.cpp
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "throwStatement.h"
+
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void ThrowStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(argument_);
+}
+
+void ThrowStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "ThrowStatement"}, {"argument", argument_}});
+}
+
+void ThrowStatement::Compile(compiler::PandaGen *pg) const
+{
+    argument_->Compile(pg);
+    pg->EmitThrow(this);
+}
+
+checker::Type *ThrowStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/throwStatement.h b/es2panda/ir/statements/throwStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..0372d8046f7a3729a60b90b17191831f236b43fa
--- /dev/null
+++ b/es2panda/ir/statements/throwStatement.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_THROW_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_THROW_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class ThrowStatement : public Statement {
+public:
+    explicit ThrowStatement(Expression *argument) : Statement(AstNodeType::THROW_STATEMENT), argument_(argument) {}
+
+    const Expression *Argument() const
+    {
+        return argument_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Expression *argument_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/tryStatement.cpp b/es2panda/ir/statements/tryStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b5733e1af3b86c9a58aa338960ea60fb6401e0eb
--- /dev/null
+++ b/es2panda/ir/statements/tryStatement.cpp
@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tryStatement.h"
+
+#include <compiler/core/pandagen.h>
+#include <compiler/core/dynamicContext.h>
+#include <compiler/base/catchTable.h>
+#include <ir/astDump.h>
+#include <ir/base/catchClause.h>
+#include <ir/statements/blockStatement.h>
+
+namespace panda::es2panda::ir {
+
+void TryStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(block_);
+
+    if (catchClause_) {
+        cb(catchClause_);
+    }
+
+    if (finalizer_) {
+        cb(finalizer_);
+    }
+}
+
+void TryStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TryStatement"},
+                 {"block", block_},
+                 {"handler", AstDumper::Nullable(catchClause_)},
+                 {"finalizer", AstDumper::Nullable(finalizer_)}});
+}
+
+void TryStatement::CompileFinally(compiler::PandaGen *pg, compiler::TryContext *tryCtx,
+                                  const compiler::TryLabelSet &labelSet) const
+{
+    compiler::RegScope rs(pg);
+    compiler::VReg exception = pg->AllocReg();
+    pg->StoreConst(this, exception, compiler::Constant::JS_HOLE);
+    pg->Branch(this, labelSet.CatchEnd());
+
+    pg->SetLabel(this, labelSet.CatchBegin());
+    pg->StoreAccumulator(this, exception);
+
+    pg->SetLabel(this, labelSet.CatchEnd());
+
+    compiler::Label *label = pg->AllocLabel();
+    pg->LoadAccumulator(this, tryCtx->FinalizerRun());
+
+    pg->BranchIfNotUndefined(this, label);
+    pg->StoreAccumulator(this, tryCtx->FinalizerRun());
+    tryCtx->EmitFinalizer();
+    pg->SetLabel(this, label);
+
+    pg->LoadAccumulator(this, exception);
+    pg->EmitRethrow(this);
+}
+
+void TryStatement::CompileTryCatchFinally(compiler::PandaGen *pg) const
+{
+    ASSERT(catchClause_ && finalizer_);
+
+    compiler::TryContext tryCtx(pg, this);
+    const auto &labelSet = tryCtx.LabelSet();
+
+    pg->SetLabel(this, labelSet.TryBegin());
+    {
+        compiler::TryContext innerTryCtx(pg, this, false);
+        const auto &innerLabelSet = innerTryCtx.LabelSet();
+
+        pg->SetLabel(this, innerLabelSet.TryBegin());
+        block_->Compile(pg);
+        pg->SetLabel(this, innerLabelSet.TryEnd());
+
+        pg->Branch(this, innerLabelSet.CatchEnd());
+
+        pg->SetLabel(this, innerLabelSet.CatchBegin());
+        catchClause_->Compile(pg);
+        pg->SetLabel(this, innerLabelSet.CatchEnd());
+    }
+    pg->SetLabel(this, labelSet.TryEnd());
+
+    CompileFinally(pg, &tryCtx, labelSet);
+}
+
+void TryStatement::CompileTryFinally(compiler::PandaGen *pg) const
+{
+    ASSERT(!catchClause_ && finalizer_);
+
+    compiler::TryContext tryCtx(pg, this);
+    const auto &labelSet = tryCtx.LabelSet();
+
+    pg->SetLabel(this, labelSet.TryBegin());
+    {
+        compiler::TryContext innerTryCtx(pg, this, false);
+        const auto &innerLabelSet = innerTryCtx.LabelSet();
+
+        pg->SetLabel(this, innerLabelSet.TryBegin());
+        block_->Compile(pg);
+        pg->SetLabel(this, innerLabelSet.TryEnd());
+
+        pg->Branch(this, innerLabelSet.CatchEnd());
+
+        pg->SetLabel(this, innerLabelSet.CatchBegin());
+        pg->EmitThrow(this);
+        pg->SetLabel(this, innerLabelSet.CatchEnd());
+    }
+    pg->SetLabel(this, labelSet.TryEnd());
+
+    CompileFinally(pg, &tryCtx, labelSet);
+}
+
+void TryStatement::CompileTryCatch(compiler::PandaGen *pg) const
+{
+    ASSERT(catchClause_ && !finalizer_);
+
+    compiler::TryContext tryCtx(pg, this);
+    const auto &labelSet = tryCtx.LabelSet();
+
+    pg->SetLabel(this, labelSet.TryBegin());
+    block_->Compile(pg);
+    pg->SetLabel(this, labelSet.TryEnd());
+
+    pg->Branch(this, labelSet.CatchEnd());
+
+    pg->SetLabel(this, labelSet.CatchBegin());
+    catchClause_->Compile(pg);
+    pg->SetLabel(this, labelSet.CatchEnd());
+}
+
+void TryStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    if (finalizer_) {
+        if (catchClause_) {
+            CompileTryCatchFinally(pg);
+        } else {
+            CompileTryFinally(pg);
+        }
+    } else {
+        CompileTryCatch(pg);
+    }
+}
+
+checker::Type *TryStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    block_->Check(checker);
+
+    if (catchClause_) {
+        catchClause_->Check(checker);
+    }
+
+    if (finalizer_) {
+        finalizer_->Check(checker);
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/tryStatement.h b/es2panda/ir/statements/tryStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..c824b99db3b96e553fb9cc0c5d22731f765ca3e2
--- /dev/null
+++ b/es2panda/ir/statements/tryStatement.h
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_TRY_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_TRY_STATEMENT_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+class TryLabelSet;
+class TryContext;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class BlockStatement;
+class CatchClause;
+
+class TryStatement : public Statement {
+public:
+    explicit TryStatement(BlockStatement *block, CatchClause *catchClause, BlockStatement *finalizer)
+        : Statement(AstNodeType::TRY_STATEMENT), block_(block), catchClause_(catchClause), finalizer_(finalizer)
+    {
+    }
+
+    const BlockStatement *FinallyBlock() const
+    {
+        return finalizer_;
+    }
+
+    BlockStatement *Block() const
+    {
+        return block_;
+    }
+
+    CatchClause *GetCatchClause() const
+    {
+        return catchClause_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    void CompileTryCatch(compiler::PandaGen *pg) const;
+    void CompileTryFinally(compiler::PandaGen *pg) const;
+    void CompileTryCatchFinally(compiler::PandaGen *pg) const;
+    void CompileFinally(compiler::PandaGen *pg, compiler::TryContext *tryCtx,
+                        const compiler::TryLabelSet &labelSet) const;
+
+    BlockStatement *block_;
+    CatchClause *catchClause_;
+    BlockStatement *finalizer_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/variableDeclaration.cpp b/es2panda/ir/statements/variableDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0e987e9889eb65c24416c8a6913b4eaa8dfbd242
--- /dev/null
+++ b/es2panda/ir/statements/variableDeclaration.cpp
@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "variableDeclaration.h"
+
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/statements/variableDeclarator.h>
+
+namespace panda::es2panda::ir {
+
+void VariableDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : declarators_) {
+        cb(it);
+    }
+}
+
+void VariableDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    const char *kind = nullptr;
+
+    switch (kind_) {
+        case VariableDeclarationKind::CONST: {
+            kind = "const";
+            break;
+        }
+        case VariableDeclarationKind::LET: {
+            kind = "let";
+            break;
+        }
+        case VariableDeclarationKind::VAR: {
+            kind = "var";
+            break;
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+
+    dumper->Add({{"type", "VariableDeclaration"},
+                 {"declarations", declarators_},
+                 {"kind", kind},
+                 {"declare", AstDumper::Optional(declare_)}});
+}
+
+void VariableDeclaration::Compile(compiler::PandaGen *pg) const
+{
+    for (const auto *it : declarators_) {
+        it->Compile(pg);
+    }
+}
+
+using TypeAnnotationDestructuringType =
+    std::tuple<binder::Variable *, const ir::Expression *, checker::DestructuringType>;
+
+static TypeAnnotationDestructuringType GetTypeAnnotationNodeAndDestructuringType(checker::Checker *checker,
+                                                                                 const ir::VariableDeclarator *decl)
+{
+    if (decl->Id()->IsArrayPattern()) {
+        if (!decl->Init()) {
+            checker->ThrowTypeError("A destructuring declaration must have an initializer", decl->Id()->Start());
+        }
+
+        return {nullptr, decl->Id()->AsArrayPattern()->TypeAnnotation(),
+                checker::DestructuringType::ARRAY_DESTRUCTURING};
+    }
+
+    if (decl->Id()->IsObjectPattern()) {
+        if (!decl->Init()) {
+            checker->ThrowTypeError("A destructuring declaration must have an initializer", decl->Id()->Start());
+        }
+
+        return {nullptr, decl->Id()->AsObjectPattern()->TypeAnnotation(),
+                checker::DestructuringType::OBJECT_DESTRUCTURING};
+    }
+
+    ASSERT(decl->Id()->IsIdentifier());
+    binder::ScopeFindResult result = checker->Scope()->Find(decl->Id()->AsIdentifier()->Name());
+    ASSERT(result.variable);
+    return {result.variable, decl->Id()->AsIdentifier()->TypeAnnotation(),
+            checker::DestructuringType::NO_DESTRUCTURING};
+}
+
+checker::Type *VariableDeclaration::Check(checker::Checker *checker) const
+{
+    for (auto *it : declarators_) {
+        auto [bindingVar, typeAnnotation, destucturingType] = GetTypeAnnotationNodeAndDestructuringType(checker, it);
+
+        // TODO(aszilagyi): binding_var
+        (void)bindingVar;
+        checker::Type *annotationType = typeAnnotation ? checker->CheckTypeCached(typeAnnotation) : nullptr;
+
+        checker::Type *initType = it->Init() ? checker->CheckTypeCached(it->Init()) : nullptr;
+
+        checker::Type *patternType =
+            destucturingType != checker::DestructuringType::NO_DESTRUCTURING ? it->Id()->Check(checker) : nullptr;
+
+        if (initType && kind_ != ir::VariableDeclaration::VariableDeclarationKind::CONST) {
+            initType = checker->GetBaseTypeOfLiteralType(initType);
+        }
+
+        checker->ValidateTypeAnnotationAndInitType(it->Init(), &initType, annotationType, patternType,
+                                                   it->Id()->Start());
+
+        /* TODO(aszilagyi) */
+        auto context = checker::VariableBindingContext::REGULAR;
+        checker->HandleVariableDeclarationWithContext(it->Id(), annotationType ? annotationType : initType, context,
+                                                      destucturingType, annotationType);
+    }
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/variableDeclaration.h b/es2panda/ir/statements/variableDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c17ce25366484aa4fe63e3666b526a18ab78257
--- /dev/null
+++ b/es2panda/ir/statements/variableDeclaration.h
@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_VARIABLE_DECLARATION_H
+#define ES2PANDA_IR_STATEMENT_VARIABLE_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class VariableDeclarator;
+
+class VariableDeclaration : public Statement {
+public:
+    enum class VariableDeclarationKind { CONST, LET, VAR };
+
+    explicit VariableDeclaration(VariableDeclarationKind kind, ArenaVector<VariableDeclarator *> &&declarators,
+                                 bool declare)
+        : Statement(AstNodeType::VARIABLE_DECLARATION),
+          kind_(kind),
+          declarators_(std::move(declarators)),
+          declare_(declare)
+    {
+    }
+
+    const ArenaVector<VariableDeclarator *> &Declarators() const
+    {
+        return declarators_;
+    }
+
+    VariableDeclarationKind Kind() const
+    {
+        return kind_;
+    }
+
+    bool Declare() const
+    {
+        return declare_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    VariableDeclarationKind kind_;
+    ArenaVector<VariableDeclarator *> declarators_;
+    bool declare_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/variableDeclarator.cpp b/es2panda/ir/statements/variableDeclarator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..64ebc7c354f1b2ecaa8591a8d34c5ef146a89dc3
--- /dev/null
+++ b/es2panda/ir/statements/variableDeclarator.cpp
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "variableDeclarator.h"
+
+#include <compiler/base/lreference.h>
+#include <compiler/core/pandagen.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+#include <ir/statements/variableDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void VariableDeclarator::Iterate(const NodeTraverser &cb) const
+{
+    cb(id_);
+
+    if (init_) {
+        cb(init_);
+    }
+}
+
+void VariableDeclarator::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "VariableDeclarator"}, {"id", id_}, {"init", AstDumper::Nullable(init_)}});
+}
+
+void VariableDeclarator::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+{
+    compiler::LReference lref = compiler::LReference::CreateLRef(pg, id_, true);
+    const ir::VariableDeclaration *decl = parent_->AsVariableDeclaration();
+
+    if (init_) {
+        init_->Compile(pg);
+    } else {
+        if (decl->Kind() == ir::VariableDeclaration::VariableDeclarationKind::VAR) {
+            return;
+        }
+        if (decl->Kind() == ir::VariableDeclaration::VariableDeclarationKind::LET && !decl->Parent()->IsCatchClause()) {
+            pg->LoadConst(this, compiler::Constant::JS_UNDEFINED);
+        }
+    }
+
+    lref.SetValue();
+}
+
+checker::Type *VariableDeclarator::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/variableDeclarator.h b/es2panda/ir/statements/variableDeclarator.h
new file mode 100644
index 0000000000000000000000000000000000000000..1962474e23711b0c822de38db597ca9c8585479d
--- /dev/null
+++ b/es2panda/ir/statements/variableDeclarator.h
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_VARIABLE_DECLARATOR_H
+#define ES2PANDA_IR_STATEMENT_VARIABLE_DECLARATOR_H
+
+#include <ir/expression.h>
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class VariableDeclarator : public Statement {
+public:
+    explicit VariableDeclarator(Expression *ident)
+        : Statement(AstNodeType::VARIABLE_DECLARATOR), id_(ident), init_(nullptr)
+    {
+    }
+
+    explicit VariableDeclarator(Expression *ident, Expression *init)
+        : Statement(AstNodeType::VARIABLE_DECLARATOR), id_(ident), init_(init)
+    {
+    }
+
+    Expression *Init()
+    {
+        return init_;
+    }
+
+    const Expression *Init() const
+    {
+        return init_;
+    }
+
+    Expression *Id()
+    {
+        return id_;
+    }
+
+    const Expression *Id() const
+    {
+        return id_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *id_;
+    Expression *init_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/statements/whileStatement.cpp b/es2panda/ir/statements/whileStatement.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..158cdc258081fa284b8b5d1232da70c24f1aaa7d
--- /dev/null
+++ b/es2panda/ir/statements/whileStatement.cpp
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "whileStatement.h"
+
+#include <binder/scope.h>
+#include <compiler/base/condition.h>
+#include <compiler/core/labelTarget.h>
+#include <compiler/core/pandagen.h>
+#include <compiler/core/regScope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void WhileStatement::Iterate(const NodeTraverser &cb) const
+{
+    cb(test_);
+    cb(body_);
+}
+
+void WhileStatement::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "WhileStatement"}, {"test", test_}, {"body", body_}});
+}
+
+void WhileStatement::Compile(compiler::PandaGen *pg) const
+{
+    compiler::LabelTarget labelTarget(pg);
+
+    pg->SetLabel(this, labelTarget.ContinueTarget());
+    compiler::Condition::Compile(pg, test_, labelTarget.BreakTarget());
+
+    {
+        compiler::LocalRegScope regScope(pg, scope_);
+        compiler::LabelContext labelCtx(pg, labelTarget);
+        body_->Compile(pg);
+    }
+
+    pg->Branch(this, labelTarget.ContinueTarget());
+    pg->SetLabel(this, labelTarget.BreakTarget());
+}
+
+checker::Type *WhileStatement::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, scope_);
+
+    checker::Type *testType = test_->Check(checker);
+    checker->CheckTruthinessOfType(testType, Start());
+
+    body_->Check(checker);
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/statements/whileStatement.h b/es2panda/ir/statements/whileStatement.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ecd528c16271caf777f0ebd662491acbb9506cc
--- /dev/null
+++ b/es2panda/ir/statements/whileStatement.h
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_STATEMENT_WHILE_STATEMENT_H
+#define ES2PANDA_IR_STATEMENT_WHILE_STATEMENT_H
+
+#include <ir/statements/loopStatement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::binder {
+class LoopScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class WhileStatement : public LoopStatement {
+public:
+    explicit WhileStatement(binder::LoopScope *scope, Expression *test, Statement *body)
+        : LoopStatement(AstNodeType::WHILE_STATEMENT, scope), test_(test), body_(body)
+    {
+    }
+
+    const Expression *Test() const
+    {
+        return test_;
+    }
+
+    Expression *Test()
+    {
+        return test_;
+    }
+
+    const Statement *Body() const
+    {
+        return body_;
+    }
+
+    Statement *Body()
+    {
+        return body_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+protected:
+    Expression *test_;
+    Statement *body_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif /* WHILE_STATEMENT_H */
diff --git a/es2panda/ir/ts/tsAnyKeyword.cpp b/es2panda/ir/ts/tsAnyKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..84ca60b157e466975d5e91d0934ae9eea0ab89aa
--- /dev/null
+++ b/es2panda/ir/ts/tsAnyKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsAnyKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSAnyKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSAnyKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSAnyKeyword"}});
+}
+
+void TSAnyKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSAnyKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsAnyKeyword.h b/es2panda/ir/ts/tsAnyKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b91322a284c40710b7d6a2644d626f516025cc4
--- /dev/null
+++ b/es2panda/ir/ts/tsAnyKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_ANY_KEYWORD_H
+#define ES2PANDA_IR_TS_ANY_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSAnyKeyword : public Expression {
+public:
+    explicit TSAnyKeyword() : Expression(AstNodeType::TS_ANY_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsArrayType.cpp b/es2panda/ir/ts/tsArrayType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85fb3294f7f113a9fdee08d5d02dfa3280a32d3e
--- /dev/null
+++ b/es2panda/ir/ts/tsArrayType.cpp
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsArrayType.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSArrayType::Iterate(const NodeTraverser &cb) const
+{
+    cb(elementType_);
+}
+
+void TSArrayType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSArrayType"}, {"elementType", elementType_}});
+}
+
+void TSArrayType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSArrayType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsArrayType.h b/es2panda/ir/ts/tsArrayType.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d1e68363ab1f0630fb60e82c6542d54bb6c7644
--- /dev/null
+++ b/es2panda/ir/ts/tsArrayType.h
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_ARRAY_TYPE_H
+#define ES2PANDA_IR_TS_ARRAY_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSArrayType : public Expression {
+public:
+    explicit TSArrayType(Expression *elementType) : Expression(AstNodeType::TS_ARRAY_TYPE), elementType_(elementType)
+    {
+    }
+
+    const Expression *ElementType() const
+    {
+        return elementType_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *elementType_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsAsExpression.cpp b/es2panda/ir/ts/tsAsExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e32fa7b86c39c8a47ead8f092f4df2dc33e6cb6
--- /dev/null
+++ b/es2panda/ir/ts/tsAsExpression.cpp
@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsAsExpression.h"
+
+#include <binder/scope.h>
+#include <typescript/checker.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literal.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/unaryExpression.h>
+
+namespace panda::es2panda::ir {
+
+void TSAsExpression::Iterate(const NodeTraverser &cb) const
+{
+    cb(expression_);
+    cb(typeAnnotation_);
+}
+
+void TSAsExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSAsExpression"}, {"expression", expression_}, {"typeAnnotation", typeAnnotation_}});
+}
+
+void TSAsExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+static bool IsValidConstAssertionArgument(checker::Checker *checker, const ir::AstNode *arg)
+{
+    switch (arg->Type()) {
+        case ir::AstNodeType::NUMBER_LITERAL:
+        case ir::AstNodeType::STRING_LITERAL:
+        case ir::AstNodeType::BIGINT_LITERAL:
+        case ir::AstNodeType::BOOLEAN_LITERAL:
+        case ir::AstNodeType::ARRAY_EXPRESSION:
+        case ir::AstNodeType::OBJECT_EXPRESSION:
+        case ir::AstNodeType::TEMPLATE_LITERAL: {
+            return true;
+        }
+        case ir::AstNodeType::UNARY_EXPRESSION: {
+            const ir::UnaryExpression *unaryExpr = arg->AsUnaryExpression();
+            lexer::TokenType op = unaryExpr->OperatorType();
+            const ir::Expression *unaryArg = unaryExpr->Argument();
+            return (op == lexer::TokenType::PUNCTUATOR_MINUS && unaryArg->IsLiteral() &&
+                    (unaryArg->AsLiteral()->IsNumberLiteral() || unaryArg->AsLiteral()->IsBigIntLiteral())) ||
+                   (op == lexer::TokenType::PUNCTUATOR_PLUS && unaryArg->IsLiteral() &&
+                    unaryArg->AsLiteral()->IsNumberLiteral());
+        }
+        case ir::AstNodeType::MEMBER_EXPRESSION: {
+            const ir::MemberExpression *memberExpr = arg->AsMemberExpression();
+            if (memberExpr->Object()->IsIdentifier()) {
+                binder::ScopeFindResult result = checker->Scope()->Find(memberExpr->Object()->AsIdentifier()->Name());
+                constexpr auto enumLiteralType = checker::EnumLiteralType::EnumLiteralTypeKind::LITERAL;
+                if (result.variable && result.variable->TsType()->HasTypeFlag(checker::TypeFlag::ENUM_LITERAL) &&
+                    result.variable->TsType()->AsEnumLiteralType()->Kind() == enumLiteralType) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        default:
+            return false;
+    }
+}
+
+checker::Type *TSAsExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    // TODO(aszilagyi): params is_const_, is_const_
+    checker::Type *exprType = expression_->Check(checker);
+
+    if (isConst_) {
+        if (!IsValidConstAssertionArgument(checker, expression_)) {
+            checker->ThrowTypeError(
+                "A 'const' assertions can only be applied to references to enum members, or string, number, "
+                "boolean, array, or object literals.",
+                expression_->Start());
+        }
+
+        return exprType;
+    }
+
+    exprType = checker->GetBaseTypeOfLiteralType(exprType);
+    if (exprType->IsObjectType() && exprType->AsObjectType()->IsObjectLiteralType()) {
+        exprType->AsObjectType()->RemoveObjectFlag(checker::ObjectType::ObjectFlags::CHECK_EXCESS_PROPS);
+    }
+
+    checker::Type *targetType = typeAnnotation_->Check(checker);
+
+    checker->IsTypeComparableTo(
+        targetType, exprType,
+        {"Conversion of type '", exprType, "' to type '", targetType,
+         "' may be a mistake because neither type sufficiently overlaps with the other. If this was ",
+         "intentional, convert the expression to 'unknown' first."},
+        Start());
+
+    return targetType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsAsExpression.h b/es2panda/ir/ts/tsAsExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..43b5c8d311d974e176e064eef39b249a8db35a79
--- /dev/null
+++ b/es2panda/ir/ts/tsAsExpression.h
@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_AS_EXPRESSION_H
+#define ES2PANDA_IR_TS_AS_EXPRESSION_H
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSAsExpression : public Expression {
+public:
+    explicit TSAsExpression(Expression *expression, Expression *typeAnnotation, bool isConst)
+        : Expression(AstNodeType::TS_AS_EXPRESSION),
+          expression_(expression),
+          typeAnnotation_(typeAnnotation),
+          isConst_(isConst)
+    {
+    }
+
+    const Expression *Expr() const
+    {
+        return expression_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    bool IsConst() const
+    {
+        return isConst_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expression_;
+    Expression *typeAnnotation_;
+    bool isConst_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsBigintKeyword.cpp b/es2panda/ir/ts/tsBigintKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ae93c99520f11d73bc68ca8ec6b23457e570cde
--- /dev/null
+++ b/es2panda/ir/ts/tsBigintKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsBigintKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSBigintKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSBigintKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSBigIntKeyword"}});
+}
+
+void TSBigintKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSBigintKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsBigintKeyword.h b/es2panda/ir/ts/tsBigintKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..f978de99cd6e9b96699beaf15e8691a516080255
--- /dev/null
+++ b/es2panda/ir/ts/tsBigintKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_BIGINT_KEYWORD_H
+#define ES2PANDA_IR_TS_BIGINT_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSBigintKeyword : public Expression {
+public:
+    explicit TSBigintKeyword() : Expression(AstNodeType::TS_BIGINT_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsBooleanKeyword.cpp b/es2panda/ir/ts/tsBooleanKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf452c958d50390fd88fdab097a5ea66c4391ba7
--- /dev/null
+++ b/es2panda/ir/ts/tsBooleanKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsBooleanKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSBooleanKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSBooleanKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSBooleanKeyword"}});
+}
+
+void TSBooleanKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSBooleanKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsBooleanKeyword.h b/es2panda/ir/ts/tsBooleanKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1bbc321990a6c3f98b0cd7372d4cc9e0cf56c15
--- /dev/null
+++ b/es2panda/ir/ts/tsBooleanKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_BOOLEAN_KEYWORD_H
+#define ES2PANDA_IR_TS_BOOLEAN_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSBooleanKeyword : public Expression {
+public:
+    explicit TSBooleanKeyword() : Expression(AstNodeType::TS_BOOLEAN_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsClassImplements.cpp b/es2panda/ir/ts/tsClassImplements.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c122178534eb8f1681d4e9196bec85466dced35f
--- /dev/null
+++ b/es2panda/ir/ts/tsClassImplements.cpp
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsClassImplements.h"
+
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+
+namespace panda::es2panda::ir {
+
+void TSClassImplements::Iterate(const NodeTraverser &cb) const
+{
+    cb(expression_);
+
+    if (typeParameters_) {
+        cb(typeParameters_);
+    }
+}
+
+void TSClassImplements::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSClassImplements"},
+                 {"expression", expression_},
+                 {"typeParameters", AstDumper::Optional(typeParameters_)}});
+}
+
+void TSClassImplements::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSClassImplements::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsClassImplements.h b/es2panda/ir/ts/tsClassImplements.h
new file mode 100644
index 0000000000000000000000000000000000000000..3926e09ae838532532dd2b12c18cf5c1430b35ae
--- /dev/null
+++ b/es2panda/ir/ts/tsClassImplements.h
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_CLASS_IMPLEMENTS_H
+#define ES2PANDA_IR_TS_CLASS_IMPLEMENTS_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterInstantiation;
+
+class TSClassImplements : public Expression {
+public:
+    explicit TSClassImplements(Expression *expression, TSTypeParameterInstantiation *typeParameters)
+        : Expression(AstNodeType::TS_AS_EXPRESSION), expression_(expression), typeParameters_(typeParameters)
+    {
+    }
+
+    const Expression *Expr() const
+    {
+        return expression_;
+    }
+
+    const TSTypeParameterInstantiation *TypeParameters() const
+    {
+        return typeParameters_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expression_;
+    TSTypeParameterInstantiation *typeParameters_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsConditionalType.cpp b/es2panda/ir/ts/tsConditionalType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cbf616e0f879c0e971417a5030a8b1871b0d7626
--- /dev/null
+++ b/es2panda/ir/ts/tsConditionalType.cpp
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsConditionalType.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSConditionalType::Iterate(const NodeTraverser &cb) const
+{
+    cb(checkType_);
+    cb(extendsType_);
+    cb(trueType_);
+    cb(falseType_);
+}
+
+void TSConditionalType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSConditionalType"},
+                 {"checkType", checkType_},
+                 {"extendsType", extendsType_},
+                 {"trueType", trueType_},
+                 {"falseType", falseType_}});
+}
+
+void TSConditionalType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSConditionalType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsConditionalType.h b/es2panda/ir/ts/tsConditionalType.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a01ad7ff355923bf3135b26b0031709c2770e03
--- /dev/null
+++ b/es2panda/ir/ts/tsConditionalType.h
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_CONDITIONAL_TYPE_H
+#define ES2PANDA_IR_TS_CONDITIONAL_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSConditionalType : public Expression {
+public:
+    explicit TSConditionalType(Expression *checkType, Expression *extendsType, Expression *trueType,
+                               Expression *falseType)
+        : Expression(AstNodeType::TS_CONDITIONAL_TYPE),
+          checkType_(checkType),
+          extendsType_(extendsType),
+          trueType_(trueType),
+          falseType_(falseType)
+    {
+    }
+
+    const Expression *CheckType() const
+    {
+        return checkType_;
+    }
+
+    const Expression *ExtendsType() const
+    {
+        return extendsType_;
+    }
+
+    const Expression *TrueType() const
+    {
+        return trueType_;
+    }
+
+    const Expression *FalseType() const
+    {
+        return falseType_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *checkType_;
+    Expression *extendsType_;
+    Expression *trueType_;
+    Expression *falseType_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsConstructorType.cpp b/es2panda/ir/ts/tsConstructorType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..61d9544af3b68a59893d222b3c886c19e80dc3fd
--- /dev/null
+++ b/es2panda/ir/ts/tsConstructorType.cpp
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsConstructorType.h"
+
+#include <binder/scope.h>
+#include <typescript/checker.h>
+#include <typescript/types/signature.h>
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void TSConstructorType::Iterate(const NodeTraverser &cb) const
+{
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    for (auto *it : params_) {
+        cb(it);
+    }
+
+    cb(returnType_);
+}
+
+void TSConstructorType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSConstructorType"},
+                 {"params", params_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"returnType", returnType_},
+                 {"abstract", AstDumper::Optional(abstract_)}});
+}
+
+void TSConstructorType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSConstructorType::Check(checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, scope_);
+
+    auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
+    checker->CheckFunctionParameterDeclaration(params_, signatureInfo);
+    checker::Type *returnType = returnType_->Check(checker);
+    auto *constructSignature = checker->Allocator()->New<checker::Signature>(signatureInfo, returnType);
+
+    return checker->CreateConstructorTypeWithSignature(constructSignature);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsConstructorType.h b/es2panda/ir/ts/tsConstructorType.h
new file mode 100644
index 0000000000000000000000000000000000000000..fcb3b70a082b6fe8a0906fc2bff047211bb1d629
--- /dev/null
+++ b/es2panda/ir/ts/tsConstructorType.h
@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_CONSTRUCTOR_TYPE_H
+#define ES2PANDA_IR_TS_CONSTRUCTOR_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::binder {
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterDeclaration;
+
+class TSConstructorType : public Expression {
+public:
+    explicit TSConstructorType(binder::Scope *scope, ArenaVector<Expression *> &&params,
+                               TSTypeParameterDeclaration *typeParams, Expression *returnType, bool abstract)
+        : Expression(AstNodeType::TS_CONSTRUCTOR_TYPE),
+          scope_(scope),
+          params_(std::move(params)),
+          typeParams_(typeParams),
+          returnType_(returnType),
+          abstract_(abstract)
+    {
+    }
+
+    binder::Scope *Scope() const
+    {
+        return scope_;
+    }
+
+    const TSTypeParameterDeclaration *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const ArenaVector<Expression *> &Params() const
+    {
+        return params_;
+    }
+
+    const Expression *ReturnType() const
+    {
+        return returnType_;
+    }
+
+    bool Abstract() const
+    {
+        return abstract_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::Scope *scope_;
+    ArenaVector<Expression *> params_;
+    TSTypeParameterDeclaration *typeParams_;
+    Expression *returnType_;
+    bool abstract_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsEnumDeclaration.cpp b/es2panda/ir/ts/tsEnumDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d92e673a355032b7a0c7f443f4cdd9f5e20b01d1
--- /dev/null
+++ b/es2panda/ir/ts/tsEnumDeclaration.cpp
@@ -0,0 +1,401 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsEnumDeclaration.h"
+
+#include <binder/scope.h>
+#include <util/helpers.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/unaryExpression.h>
+#include <ir/expressions/binaryExpression.h>
+#include <ir/expressions/templateLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/ts/tsEnumMember.h>
+#include <typescript/checker.h>
+
+namespace panda::es2panda::ir {
+
+void TSEnumDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+
+    for (auto *it : members_) {
+        cb(it);
+    }
+}
+
+void TSEnumDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSEnumDeclaration"}, {"id", key_}, {"members", members_}, {"const", isConst_}});
+}
+
+void TSEnumDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+int32_t ToInt(double num)
+{
+    if (num >= std::numeric_limits<int32_t>::min() && num <= std::numeric_limits<int32_t>::max()) {
+        return static_cast<int32_t>(num);
+    }
+
+    // TODO(aszilagyi): Perform ECMA defined toInt conversion
+
+    return 0;
+}
+
+uint32_t ToUInt(double num)
+{
+    if (num >= std::numeric_limits<uint32_t>::min() && num <= std::numeric_limits<uint32_t>::max()) {
+        return static_cast<int32_t>(num);
+    }
+
+    // TODO(aszilagyi): Perform ECMA defined toInt conversion
+
+    return 0;
+}
+
+binder::EnumMemberResult EvaluateIdentifier(checker::Checker *checker, binder::EnumVariable *enumVar,
+                                            const ir::Identifier *expr)
+{
+    if (expr->Name() == "NaN") {
+        return std::nan("");
+    }
+    if (expr->Name() == "Infinity") {
+        return std::numeric_limits<double>::infinity();
+    }
+
+    binder::Variable *enumMember = expr->AsIdentifier()->Variable();
+
+    if (!enumMember) {
+        checker->ThrowTypeError({"Cannot find name ", expr->AsIdentifier()->Name()},
+                                enumVar->Declaration()->Node()->Start());
+    }
+
+    if (enumMember->IsEnumVariable()) {
+        binder::EnumVariable *exprEnumVar = enumMember->AsEnumVariable();
+        if (std::holds_alternative<bool>(exprEnumVar->Value())) {
+            checker->ThrowTypeError(
+                "A member initializer in a enum declaration cannot reference members declared after it, "
+                "including "
+                "members defined in other enums.",
+                enumVar->Declaration()->Node()->Start());
+        }
+
+        return exprEnumVar->Value();
+    }
+
+    return false;
+}
+
+binder::EnumMemberResult EvaluateUnaryExpression(checker::Checker *checker, binder::EnumVariable *enumVar,
+                                                 const ir::UnaryExpression *expr)
+{
+    binder::EnumMemberResult value = TSEnumDeclaration::EvaluateEnumMember(checker, enumVar, expr->Argument());
+    if (!std::holds_alternative<double>(value)) {
+        return false;
+    }
+
+    switch (expr->OperatorType()) {
+        case lexer::TokenType::PUNCTUATOR_PLUS: {
+            return std::get<double>(value);
+        }
+        case lexer::TokenType::PUNCTUATOR_MINUS: {
+            return -std::get<double>(value);
+        }
+        case lexer::TokenType::PUNCTUATOR_TILDE: {
+            return static_cast<double>(~ToInt(std::get<double>(value)));
+        }
+        default: {
+            break;
+        }
+    }
+
+    return false;
+}
+
+binder::EnumMemberResult EvaluateMemberExpression(checker::Checker *checker,
+                                                  [[maybe_unused]] binder::EnumVariable *enumVar,
+                                                  const ir::MemberExpression *expr)
+{
+    if (checker::Checker::IsConstantMemberAccess(expr->AsExpression())) {
+        if (expr->Check(checker)->TypeFlags() == checker::TypeFlag::ENUM) {
+            util::StringView name;
+            if (!expr->IsComputed()) {
+                name = expr->Property()->AsIdentifier()->Name();
+            } else {
+                ASSERT(checker::Checker::IsStringLike(expr->Property()));
+                name = reinterpret_cast<const ir::StringLiteral *>(expr->Property())->Str();
+            }
+
+            // TODO(aszilagyi)
+        }
+    }
+
+    return false;
+}
+
+binder::EnumMemberResult EvaluateBinaryExpression(checker::Checker *checker, binder::EnumVariable *enumVar,
+                                                  const ir::BinaryExpression *expr)
+{
+    binder::EnumMemberResult left =
+        TSEnumDeclaration::EvaluateEnumMember(checker, enumVar, expr->AsBinaryExpression()->Left());
+    binder::EnumMemberResult right =
+        TSEnumDeclaration::EvaluateEnumMember(checker, enumVar, expr->AsBinaryExpression()->Right());
+    if (std::holds_alternative<double>(left) && std::holds_alternative<double>(right)) {
+        switch (expr->AsBinaryExpression()->OperatorType()) {
+            case lexer::TokenType::PUNCTUATOR_BITWISE_OR: {
+                return static_cast<double>(ToUInt(std::get<double>(left)) | ToUInt(std::get<double>(right)));
+            }
+            case lexer::TokenType::PUNCTUATOR_BITWISE_AND: {
+                return static_cast<double>(ToUInt(std::get<double>(left)) & ToUInt(std::get<double>(right)));
+            }
+            case lexer::TokenType::PUNCTUATOR_BITWISE_XOR: {
+                return static_cast<double>(ToUInt(std::get<double>(left)) ^ ToUInt(std::get<double>(right)));
+            }
+            case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT: {
+                return static_cast<double>(ToInt(std::get<double>(left)) << ToUInt(std::get<double>(right)));
+            }
+            case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT: {
+                return static_cast<double>(ToInt(std::get<double>(left)) >> ToUInt(std::get<double>(right)));
+            }
+            case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT: {
+                return static_cast<double>(ToUInt(std::get<double>(left)) >> ToUInt(std::get<double>(right)));
+            }
+            case lexer::TokenType::PUNCTUATOR_PLUS: {
+                return std::get<double>(left) + std::get<double>(right);
+            }
+            case lexer::TokenType::PUNCTUATOR_MINUS: {
+                return std::get<double>(left) - std::get<double>(right);
+            }
+            case lexer::TokenType::PUNCTUATOR_MULTIPLY: {
+                return std::get<double>(left) * std::get<double>(right);
+            }
+            case lexer::TokenType::PUNCTUATOR_DIVIDE: {
+                return std::get<double>(left) / std::get<double>(right);
+            }
+            case lexer::TokenType::PUNCTUATOR_MOD: {
+                return std::fmod(std::get<double>(left), std::get<double>(right));
+            }
+            case lexer::TokenType::PUNCTUATOR_EXPONENTIATION: {
+                return std::pow(std::get<double>(left), std::get<double>(right));
+            }
+            default: {
+                break;
+            }
+        }
+
+        return false;
+    }
+
+    if (std::holds_alternative<util::StringView>(left) && std::holds_alternative<util::StringView>(right) &&
+        expr->AsBinaryExpression()->OperatorType() == lexer::TokenType::PUNCTUATOR_PLUS) {
+        std::stringstream ss;
+        ss << std::get<util::StringView>(left) << std::get<util::StringView>(right);
+
+        util::UString res(ss.str(), checker->Allocator());
+        return res.View();
+    }
+
+    return false;
+}
+
+binder::EnumMemberResult TSEnumDeclaration::EvaluateEnumMember(checker::Checker *checker, binder::EnumVariable *enumVar,
+                                                               const ir::AstNode *expr)
+{
+    switch (expr->Type()) {
+        case ir::AstNodeType::UNARY_EXPRESSION: {
+            return EvaluateUnaryExpression(checker, enumVar, expr->AsUnaryExpression());
+        }
+        case ir::AstNodeType::BINARY_EXPRESSION: {
+            return EvaluateBinaryExpression(checker, enumVar, expr->AsBinaryExpression());
+        }
+        case ir::AstNodeType::NUMBER_LITERAL: {
+            return expr->AsNumberLiteral()->Number();
+        }
+        case ir::AstNodeType::STRING_LITERAL: {
+            return expr->AsStringLiteral()->Str();
+        }
+        case ir::AstNodeType::IDENTIFIER: {
+            return EvaluateIdentifier(checker, enumVar, expr->AsIdentifier());
+        }
+        case ir::AstNodeType::MEMBER_EXPRESSION: {
+            return EvaluateEnumMember(checker, enumVar, expr->AsMemberExpression());
+        }
+        default:
+            break;
+    }
+
+    return false;
+}
+
+bool IsComputedEnumMember(const ir::Expression *init)
+{
+    if (init->IsLiteral()) {
+        return !init->AsLiteral()->IsStringLiteral() && !init->AsLiteral()->IsNumberLiteral();
+    }
+
+    if (init->IsTemplateLiteral()) {
+        return !init->AsTemplateLiteral()->Quasis().empty();
+    }
+
+    return true;
+}
+
+void AddEnumValueDeclaration(checker::Checker *checker, double number, binder::EnumVariable *variable)
+{
+    variable->SetTsType(checker->GlobalNumberType());
+
+    util::StringView memberStr = util::Helpers::ToStringView(checker->Allocator(), number);
+
+    binder::LocalScope *enumScope = checker->Scope()->AsLocalScope();
+    binder::Variable *res = enumScope->FindLocal(memberStr);
+    binder::EnumVariable *enumVar = nullptr;
+
+    if (!res) {
+        auto *decl = checker->Allocator()->New<binder::EnumDecl>(memberStr);
+        decl->BindNode(variable->Declaration()->Node());
+        enumScope->AddDecl(checker->Allocator(), decl, ScriptExtension::TS);
+        res = enumScope->FindLocal(memberStr);
+        ASSERT(res && res->IsEnumVariable());
+        enumVar = res->AsEnumVariable();
+        enumVar->AsEnumVariable()->SetBackReference();
+        enumVar->SetTsType(checker->GlobalStringType());
+    } else {
+        ASSERT(res->IsEnumVariable());
+        enumVar = res->AsEnumVariable();
+        auto *decl = checker->Allocator()->New<binder::EnumDecl>(memberStr);
+        decl->BindNode(variable->Declaration()->Node());
+        enumVar->ResetDecl(decl);
+    }
+
+    enumVar->SetValue(variable->Declaration()->Name());
+}
+
+void InferEnumVariableType(checker::Checker *checker, binder::EnumVariable *variable, double *value, bool *initNext,
+                           bool *isLiteralEnum, bool isConstEnum, const ir::Expression *computedExpr)
+{
+    const ir::Expression *init = variable->Declaration()->Node()->AsTSEnumMember()->Init();
+
+    if (!init && *initNext) {
+        checker->ThrowTypeError("Enum member must have initializer.", variable->Declaration()->Node()->Start());
+    }
+
+    if (!init && !*initNext) {
+        variable->SetValue(++(*value));
+        AddEnumValueDeclaration(checker, *value, variable);
+        return;
+    }
+
+    ASSERT(init);
+
+    if (IsComputedEnumMember(init)) {
+        if (*isLiteralEnum) {
+            checker->ThrowTypeError("Computed values are not permitted in an enum with string valued members.",
+                                    init->Start());
+        }
+
+        computedExpr = init;
+    }
+
+    binder::EnumMemberResult res = TSEnumDeclaration::EvaluateEnumMember(checker, variable, init);
+    if (std::holds_alternative<util::StringView>(res)) {
+        if (computedExpr) {
+            checker->ThrowTypeError("Computed values are not permitted in an enum with string valued members.",
+                                    computedExpr->Start());
+        }
+
+        *isLiteralEnum = true;
+        variable->SetTsType(checker->GlobalStringType());
+        *initNext = true;
+        return;
+    }
+
+    if (std::holds_alternative<bool>(res)) {
+        if (isConstEnum) {
+            checker->ThrowTypeError(
+                "const enum member initializers can only contain literal values and other computed enum "
+                "values.",
+                init->Start());
+        }
+
+        *initNext = true;
+        return;
+    }
+
+    ASSERT(std::holds_alternative<double>(res));
+    variable->SetValue(res);
+
+    *value = std::get<double>(res);
+    if (isConstEnum) {
+        if (std::isnan(*value)) {
+            checker->ThrowTypeError("'const' enum member initializer was evaluated to disallowed value 'NaN'.",
+                                    init->Start());
+        }
+
+        if (std::isinf(*value)) {
+            checker->ThrowTypeError("'const' enum member initializer was evaluated to a non-finite value.",
+                                    init->Start());
+        }
+    }
+
+    *initNext = false;
+    AddEnumValueDeclaration(checker, *value, variable);
+}
+
+checker::Type *TSEnumDeclaration::InferType(checker::Checker *checker, bool isConst) const
+{
+    double value = -1.0;
+
+    binder::LocalScope *enumScope = checker->Scope()->AsLocalScope();
+
+    bool initNext = false;
+    bool isLiteralEnum = false;
+    const ir::Expression *computedExpr = nullptr;
+    size_t localsSize = enumScope->Decls().size();
+
+    for (size_t i = 0; i < localsSize; i++) {
+        const util::StringView &currentName = enumScope->Decls()[i]->Name();
+        binder::Variable *currentVar = enumScope->FindLocal(currentName);
+        ASSERT(currentVar && currentVar->IsEnumVariable());
+        InferEnumVariableType(checker, currentVar->AsEnumVariable(), &value, &initNext, &isLiteralEnum, isConst,
+                              computedExpr);
+    }
+
+    checker::Type *enumType = checker->Allocator()->New<checker::EnumLiteralType>(
+        key_->Name(), checker->Scope(),
+        isLiteralEnum ? checker::EnumLiteralType::EnumLiteralTypeKind::LITERAL
+                      : checker::EnumLiteralType::EnumLiteralTypeKind::NUMERIC);
+
+    return enumType;
+}
+
+checker::Type *TSEnumDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    binder::Variable *enumVar = key_->Variable();
+    ASSERT(enumVar);
+
+    if (!enumVar->TsType()) {
+        checker::ScopeContext scopeCtx(checker, scope_);
+        checker::Type *enumType = InferType(checker, isConst_);
+        enumType->SetVariable(enumVar);
+        enumVar->SetTsType(enumType);
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsEnumDeclaration.h b/es2panda/ir/ts/tsEnumDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..6baa9c7ccc40883a0c59de795a2dde632a4cdee1
--- /dev/null
+++ b/es2panda/ir/ts/tsEnumDeclaration.h
@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_ENUM_DECLARATION_H
+#define ES2PANDA_IR_TS_ENUM_DECLARATION_H
+
+#include <ir/statement.h>
+#include <binder/enumMemberResult.h>
+
+namespace panda::es2panda::binder {
+class LocalScope;
+class EnumVariable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+class TSEnumMember;
+
+class TSEnumDeclaration : public Statement {
+public:
+    explicit TSEnumDeclaration(binder::LocalScope *scope, Identifier *key, ArenaVector<TSEnumMember *> &&members,
+                               bool isConst)
+        : Statement(AstNodeType::TS_ENUM_DECLARATION),
+          scope_(scope),
+          key_(key),
+          members_(std::move(members)),
+          isConst_(isConst)
+    {
+    }
+
+    binder::LocalScope *Scope() const
+    {
+        return scope_;
+    }
+
+    const Identifier *Key() const
+    {
+        return key_;
+    }
+
+    const ArenaVector<TSEnumMember *> &Members() const
+    {
+        return members_;
+    }
+
+    bool IsConst() const
+    {
+        return isConst_;
+    }
+
+    static binder::EnumMemberResult EvaluateEnumMember(checker::Checker *checker, binder::EnumVariable *enumVar,
+                                                       const ir::AstNode *expr);
+    checker::Type *InferType(checker::Checker *checker, bool isConst) const;
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::LocalScope *scope_;
+    Identifier *key_;
+    ArenaVector<TSEnumMember *> members_;
+    bool isConst_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsEnumMember.cpp b/es2panda/ir/ts/tsEnumMember.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..55a38d3cdcb53895e6ebae6d21e31495f4cff65c
--- /dev/null
+++ b/es2panda/ir/ts/tsEnumMember.cpp
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsEnumMember.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void TSEnumMember::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+
+    if (init_) {
+        cb(init_);
+    }
+}
+
+void TSEnumMember::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSEnumMember"}, {"id", key_}, {"initializer", AstDumper::Optional(init_)}});
+}
+
+void TSEnumMember::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSEnumMember::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsEnumMember.h b/es2panda/ir/ts/tsEnumMember.h
new file mode 100644
index 0000000000000000000000000000000000000000..8de6f9d3decc6b4268ce385c9dd321b456a71b5b
--- /dev/null
+++ b/es2panda/ir/ts/tsEnumMember.h
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_ENUM_MEMBER_H
+#define ES2PANDA_IR_TS_ENUM_MEMBER_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class TSEnumMember : public Statement {
+public:
+    explicit TSEnumMember(Expression *key, Expression *init)
+        : Statement(AstNodeType::TS_ENUM_MEMBER), key_(key), init_(init)
+    {
+    }
+
+    const Expression *Key() const
+    {
+        return key_;
+    }
+
+    const Expression *Init() const
+    {
+        return init_;
+    }
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *key_;
+    Expression *init_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsExternalModuleReference.cpp b/es2panda/ir/ts/tsExternalModuleReference.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..67f731168db60b3bede5a721f63fdc5a246aec7a
--- /dev/null
+++ b/es2panda/ir/ts/tsExternalModuleReference.cpp
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsExternalModuleReference.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSExternalModuleReference::Iterate(const NodeTraverser &cb) const
+{
+    cb(expr_);
+}
+
+void TSExternalModuleReference::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSExternalModuleReference"}, {"expression", expr_}});
+}
+
+void TSExternalModuleReference::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSExternalModuleReference::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsExternalModuleReference.h b/es2panda/ir/ts/tsExternalModuleReference.h
new file mode 100644
index 0000000000000000000000000000000000000000..d89233126b5fac527f494ff5d104e00aa99e864e
--- /dev/null
+++ b/es2panda/ir/ts/tsExternalModuleReference.h
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_EXTERNAL_MODULE_REFERENCE_H
+#define ES2PANDA_IR_TS_EXTERNAL_MODULE_REFERENCE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSExternalModuleReference : public Expression {
+public:
+    explicit TSExternalModuleReference(Expression *expr)
+        : Expression(AstNodeType::TS_EXTERNAL_MODULE_REFERENCE), expr_(expr)
+    {
+    }
+
+    const Expression *Expr() const
+    {
+        return expr_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expr_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsFunctionType.cpp b/es2panda/ir/ts/tsFunctionType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..43e12a305adcd1f0e0c69cea75a20fe33129e7a8
--- /dev/null
+++ b/es2panda/ir/ts/tsFunctionType.cpp
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsFunctionType.h"
+
+#include <binder/scope.h>
+#include <typescript/checker.h>
+#include <typescript/types/signature.h>
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void TSFunctionType::Iterate(const NodeTraverser &cb) const
+{
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    for (auto *it : params_) {
+        cb(it);
+    }
+
+    cb(returnType_);
+}
+
+void TSFunctionType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSFunctionType"},
+                 {"params", params_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"returnType", returnType_}});
+}
+
+void TSFunctionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSFunctionType::Check(checker::Checker *checker) const
+{
+    checker::ScopeContext scopeCtx(checker, scope_);
+
+    auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
+    checker->CheckFunctionParameterDeclaration(params_, signatureInfo);
+    checker::Type *returnType = returnType_->Check(checker);
+    auto *callSignature = checker->Allocator()->New<checker::Signature>(signatureInfo, returnType);
+
+    return checker->CreateFunctionTypeWithSignature(callSignature);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsFunctionType.h b/es2panda/ir/ts/tsFunctionType.h
new file mode 100644
index 0000000000000000000000000000000000000000..49f9d9fc8950259bafbfa00ad5c8cbf8640c1fe7
--- /dev/null
+++ b/es2panda/ir/ts/tsFunctionType.h
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_FUNCTION_TYPE_H
+#define ES2PANDA_IR_TS_FUNCTION_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::binder {
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterDeclaration;
+
+class TSFunctionType : public Expression {
+public:
+    explicit TSFunctionType(binder::Scope *scope, ArenaVector<Expression *> &&params,
+                            TSTypeParameterDeclaration *typeParams, Expression *returnType)
+        : Expression(AstNodeType::TS_FUNCTION_TYPE),
+          scope_(scope),
+          params_(std::move(params)),
+          typeParams_(typeParams),
+          returnType_(returnType)
+    {
+    }
+
+    binder::Scope *Scope() const
+    {
+        return scope_;
+    }
+
+    const TSTypeParameterDeclaration *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const ArenaVector<Expression *> &Params() const
+    {
+        return params_;
+    }
+
+    const Expression *ReturnType() const
+    {
+        return returnType_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::Scope *scope_;
+    ArenaVector<Expression *> params_;
+    TSTypeParameterDeclaration *typeParams_;
+    Expression *returnType_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsImportEqualsDeclaration.cpp b/es2panda/ir/ts/tsImportEqualsDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89b612bc1d711f37081f8bb70bc4010b2b8e264d
--- /dev/null
+++ b/es2panda/ir/ts/tsImportEqualsDeclaration.cpp
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsImportEqualsDeclaration.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void TSImportEqualsDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(id_);
+    cb(moduleReference_);
+}
+
+void TSImportEqualsDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSImportEqualsDeclaration"},
+                 {"id", id_},
+                 {"moduleReference", moduleReference_},
+                 {"isExport", isExport_}});
+}
+
+void TSImportEqualsDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSImportEqualsDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsImportEqualsDeclaration.h b/es2panda/ir/ts/tsImportEqualsDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bcd9e65ca778243c709d6595f8738fe018edfb4
--- /dev/null
+++ b/es2panda/ir/ts/tsImportEqualsDeclaration.h
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_IMPORT_EQUALS_DECLARATION_H
+#define ES2PANDA_IR_TS_IMPORT_EQUALS_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class TSImportEqualsDeclaration : public Statement {
+public:
+    explicit TSImportEqualsDeclaration(Identifier *id, Expression *moduleReference, bool isExport)
+        : Statement(AstNodeType::TS_IMPORT_EQUALS_DECLARATION),
+          id_(id),
+          moduleReference_(moduleReference),
+          isExport_(isExport)
+    {
+    }
+
+    const Identifier *Id() const
+    {
+        return id_;
+    }
+
+    const Expression *ModuleReference() const
+    {
+        return moduleReference_;
+    }
+
+    bool IsExport() const
+    {
+        return isExport_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Identifier *id_;
+    Expression *moduleReference_;
+    bool isExport_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsImportType.cpp b/es2panda/ir/ts/tsImportType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..06b65b31a3a8b8ac98bedc605d205c840db07e3d
--- /dev/null
+++ b/es2panda/ir/ts/tsImportType.cpp
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsImportType.h"
+
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+
+namespace panda::es2panda::ir {
+
+void TSImportType::Iterate(const NodeTraverser &cb) const
+{
+    cb(param_);
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    if (qualifier_) {
+        cb(qualifier_);
+    }
+}
+
+void TSImportType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSImportType"},
+                 {"parameter", param_},
+                 {"qualifier", AstDumper::Optional(qualifier_)},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"isTypeOf", isTypeof_}});
+}
+
+void TSImportType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSImportType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsImportType.h b/es2panda/ir/ts/tsImportType.h
new file mode 100644
index 0000000000000000000000000000000000000000..08a6c675aa2d118370b55cd2eaa215d92a285755
--- /dev/null
+++ b/es2panda/ir/ts/tsImportType.h
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_IMPORT_TYPE_H
+#define ES2PANDA_IR_TS_IMPORT_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterInstantiation;
+
+class TSImportType : public Expression {
+public:
+    explicit TSImportType(Expression *param, TSTypeParameterInstantiation *typeParams, Expression *qualifier,
+                          bool isTypeof)
+        : Expression(AstNodeType::TS_IMPORT_TYPE),
+          param_(param),
+          typeParams_(typeParams),
+          qualifier_(qualifier),
+          isTypeof_(isTypeof)
+    {
+    }
+
+    const Expression *Param() const
+    {
+        return param_;
+    }
+
+    const TSTypeParameterInstantiation *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const Expression *Qualifier() const
+    {
+        return qualifier_;
+    }
+
+    bool IsTypeof() const
+    {
+        return isTypeof_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *param_;
+    TSTypeParameterInstantiation *typeParams_;
+    Expression *qualifier_;
+    bool isTypeof_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsIndexSignature.cpp b/es2panda/ir/ts/tsIndexSignature.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..67c106b1214e040b120f870333416279b176ed76
--- /dev/null
+++ b/es2panda/ir/ts/tsIndexSignature.cpp
@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsIndexSignature.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+TSIndexSignature::TSIndexSignatureKind TSIndexSignature::Kind() const
+{
+    return param_->AsIdentifier()->TypeAnnotation()->IsTSNumberKeyword() ? TSIndexSignatureKind::NUMBER
+                                                                         : TSIndexSignatureKind::STRING;
+}
+
+void TSIndexSignature::Iterate(const NodeTraverser &cb) const
+{
+    cb(param_);
+    cb(typeAnnotation_);
+}
+
+void TSIndexSignature::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSIndexSignature"},
+                 {"parameters", param_},
+                 {"typeAnnotation", typeAnnotation_},
+                 {"readonly", readonly_}});
+}
+
+void TSIndexSignature::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSIndexSignature::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsIndexSignature.h b/es2panda/ir/ts/tsIndexSignature.h
new file mode 100644
index 0000000000000000000000000000000000000000..334b042033c3069f8e63e17d059de8fc9a07bff3
--- /dev/null
+++ b/es2panda/ir/ts/tsIndexSignature.h
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_INDEX_SIGNATURE_H
+#define ES2PANDA_IR_TS_INDEX_SIGNATURE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSIndexSignature : public Expression {
+public:
+    enum class TSIndexSignatureKind { NUMBER, STRING };
+
+    explicit TSIndexSignature(Expression *param, Expression *typeAnnotation, bool readonly)
+        : Expression(AstNodeType::TS_INDEX_SIGNATURE),
+          param_(param),
+          typeAnnotation_(typeAnnotation),
+          readonly_(readonly)
+    {
+    }
+
+    const Expression *Param() const
+    {
+        return param_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    bool Readonly() const
+    {
+        return readonly_;
+    }
+
+    TSIndexSignatureKind Kind() const;
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *param_;
+    Expression *typeAnnotation_;
+    bool readonly_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif /* TS_INDEX_SIGNATURE_H */
diff --git a/es2panda/ir/ts/tsIndexedAccessType.cpp b/es2panda/ir/ts/tsIndexedAccessType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2e55dce32d7dc5e02c0c5ef9298160d7ab88bef6
--- /dev/null
+++ b/es2panda/ir/ts/tsIndexedAccessType.cpp
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsIndexedAccessType.h"
+
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSIndexedAccessType::Iterate(const NodeTraverser &cb) const
+{
+    cb(objectType_);
+    cb(indexType_);
+}
+
+void TSIndexedAccessType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSIndexedAccessType"}, {"objectType", objectType_}, {"indexType", indexType_}});
+}
+
+void TSIndexedAccessType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSIndexedAccessType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::Type *baseType = objectType_->Check(checker);
+    checker::Type *propType = checker->ResolveBaseProp(baseType, indexType_, false, Start());
+
+    return propType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsIndexedAccessType.h b/es2panda/ir/ts/tsIndexedAccessType.h
new file mode 100644
index 0000000000000000000000000000000000000000..20ca95fe004b37de5572c00efef1fa5be10dae91
--- /dev/null
+++ b/es2panda/ir/ts/tsIndexedAccessType.h
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_INDEXED_ACCESS_TYPE_H
+#define ES2PANDA_IR_TS_INDEXED_ACCESS_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSIndexedAccessType : public Expression {
+public:
+    explicit TSIndexedAccessType(Expression *objectType, Expression *indexType)
+        : Expression(AstNodeType::TS_INDEXED_ACCESS_TYPE), objectType_(objectType), indexType_(indexType)
+    {
+    }
+
+    const Expression *ObjectType() const
+    {
+        return objectType_;
+    }
+
+    const Expression *IndexType() const
+    {
+        return indexType_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *objectType_;
+    Expression *indexType_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsInferType.cpp b/es2panda/ir/ts/tsInferType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e549496ca53fb4eb8f5141b4ae2f62f388193f00
--- /dev/null
+++ b/es2panda/ir/ts/tsInferType.cpp
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsInferType.h"
+
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+
+namespace panda::es2panda::ir {
+
+void TSInferType::Iterate(const NodeTraverser &cb) const
+{
+    cb(typeParam_);
+}
+
+void TSInferType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSInferType"}, {"typeParameter", typeParam_}});
+}
+
+void TSInferType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSInferType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsInferType.h b/es2panda/ir/ts/tsInferType.h
new file mode 100644
index 0000000000000000000000000000000000000000..9eead52a34e2e134eaa01f503b366a20fefbb1cf
--- /dev/null
+++ b/es2panda/ir/ts/tsInferType.h
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_INFER_TYPE_H
+#define ES2PANDA_IR_TS_INFER_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameter;
+
+class TSInferType : public Expression {
+public:
+    explicit TSInferType(TSTypeParameter *typeParam) : Expression(AstNodeType::TS_INFER_TYPE), typeParam_(typeParam)
+    {
+    }
+
+    const TSTypeParameter *TypeParam() const
+    {
+        return typeParam_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    TSTypeParameter *typeParam_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsInterfaceBody.cpp b/es2panda/ir/ts/tsInterfaceBody.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..66c87f8d2a7e9812567add77e9de2b3b864fc57b
--- /dev/null
+++ b/es2panda/ir/ts/tsInterfaceBody.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsInterfaceBody.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSInterfaceBody::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : body_) {
+        cb(it);
+    }
+}
+
+void TSInterfaceBody::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSInterfaceBody"}, {"body", body_}});
+}
+
+void TSInterfaceBody::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSInterfaceBody::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsInterfaceBody.h b/es2panda/ir/ts/tsInterfaceBody.h
new file mode 100644
index 0000000000000000000000000000000000000000..1aed06f628197e0684930721883dea4351ad23bf
--- /dev/null
+++ b/es2panda/ir/ts/tsInterfaceBody.h
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_INTERFACE_BODY_H
+#define ES2PANDA_IR_TS_INTERFACE_BODY_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSInterfaceBody : public Expression {
+public:
+    explicit TSInterfaceBody(ArenaVector<Expression *> &&body)
+        : Expression(AstNodeType::TS_INTERFACE_BODY), body_(std::move(body))
+    {
+    }
+
+    const ArenaVector<Expression *> &Body() const
+    {
+        return body_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ArenaVector<Expression *> body_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsInterfaceDeclaration.cpp b/es2panda/ir/ts/tsInterfaceDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6046a09be05b03b24637c0d023cd2bb763193834
--- /dev/null
+++ b/es2panda/ir/ts/tsInterfaceDeclaration.cpp
@@ -0,0 +1,212 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsInterfaceDeclaration.h"
+
+#include <binder/declaration.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/ts/tsInterfaceBody.h>
+#include <ir/ts/tsInterfaceHeritage.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void TSInterfaceDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(id_);
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    cb(body_);
+
+    for (auto *it : extends_) {
+        cb(it);
+    }
+}
+
+void TSInterfaceDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSInterfaceDeclaration"},
+                 {"body", body_},
+                 {"id", id_},
+                 {"extends", extends_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)}});
+}
+
+void TSInterfaceDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+void CheckInheritedPropertiesAreIdentical(checker::Checker *checker, checker::InterfaceType *type,
+                                          lexer::SourcePosition locInfo)
+{
+    if (type->Bases().size() < 2) {
+        return;
+    }
+
+    checker::InterfacePropertyMap properties;
+
+    for (auto *it : type->Properties()) {
+        properties.insert({it->Name(), {it, type}});
+    }
+
+    for (auto *base : type->Bases()) {
+        std::vector<binder::LocalVariable *> inheritedProperties;
+        base->AsInterfaceType()->CollectProperties(&inheritedProperties);
+
+        for (auto *inheritedProp : inheritedProperties) {
+            auto res = properties.find(inheritedProp->Name());
+            if (res == properties.end()) {
+                properties.insert({inheritedProp->Name(), {inheritedProp, base->AsInterfaceType()}});
+            } else if (res->second.second != type) {
+                checker->IsTypeIdenticalTo(inheritedProp->TsType(), res->second.first->TsType(),
+                                           {"Interface '", type, "' cannot simultaneously extend types '",
+                                            res->second.second, "' and '", base->AsInterfaceType(), "'."},
+                                           locInfo);
+            }
+        }
+    }
+}
+
+checker::Type *TSInterfaceDeclaration::InferType(checker::Checker *checker, binder::Variable *bindingVar) const
+{
+    auto *decl = bindingVar->Declaration();
+    checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+    std::set<const ir::TSInterfaceHeritage *> extendsSet;
+    const auto &declarations = decl->AsInterfaceDecl()->Decls();
+    ASSERT(!declarations.empty());
+
+    checker::InterfaceType *newInterface = checker->Allocator()->New<checker::InterfaceType>(decl->Name(), desc);
+    newInterface->SetVariable(bindingVar);
+    bindingVar->SetTsType(newInterface);
+
+    std::pair<std::vector<binder::Variable *>, size_t> mergedTypeParams =
+        checker->CollectTypeParametersFromDeclarations(declarations);
+
+    newInterface->SetMergedTypeParams(std::move(mergedTypeParams));
+
+    for (const auto *it : declarations) {
+        const ir::TSInterfaceDeclaration *currentDecl = it->AsTSInterfaceDeclaration();
+
+        checker::ScopeContext scopeCtx(checker, currentDecl->Scope());
+
+        bool throwTypeParameterMismatchError = false;
+
+        if (currentDecl->TypeParams()) {
+            std::vector<binder::Variable *> typeParams = checker->CheckTypeParameters(currentDecl->TypeParams());
+
+            throwTypeParameterMismatchError =
+                checker->CheckTypeParametersAreIdentical(newInterface->GetMergedTypeParams(), typeParams);
+        } else if (!newInterface->GetMergedTypeParams().first.empty() &&
+                   newInterface->GetMergedTypeParams().second != 0) {
+            throwTypeParameterMismatchError = true;
+        }
+
+        if (throwTypeParameterMismatchError) {
+            checker->ThrowTypeError(
+                {"All declarations of '", newInterface->Name(), "' must have identical type parameters."},
+                currentDecl->Id()->Start());
+        }
+
+        for (const auto *iter : currentDecl->Body()->AsTSInterfaceBody()->Body()) {
+            if (iter->IsTSPropertySignature() || iter->IsTSMethodSignature()) {
+                checker->PrefetchTypeLiteralProperties(iter, desc);
+            }
+        }
+
+        for (auto *member : currentDecl->Body()->AsTSInterfaceBody()->Body()) {
+            checker->CheckTsTypeLiteralOrInterfaceMember(member, desc);
+        }
+
+        for (const auto *extends : currentDecl->Extends()) {
+            // TODO(Csaba Repasi): Handle TSQualifiedName here
+
+            binder::Variable *extendsVar = extends->Expr()->AsIdentifier()->Variable();
+
+            if (!extendsVar) {
+                checker->ThrowTypeError({"Cannot find name ", extendsVar->Name()}, extends->Start());
+            }
+
+            if (!extendsVar->HasFlag(binder::VariableFlags::INTERFACE)) {
+                checker->ThrowTypeError(
+                    "An interface can only extend an object type or intersection of object types with statically "
+                    "known "
+                    "members",
+                    extends->Start());
+            }
+
+            extendsSet.insert(extends);
+        }
+    }
+
+    for (const auto *base : extendsSet) {
+        // TODO(Csaba Repasi): Handle TSQualifiedName here
+        binder::Variable *extendsVar = base->Expr()->AsIdentifier()->Variable();
+
+        if (!checker->TypeStack().insert(extendsVar->Declaration()->Node()).second) {
+            checker->ThrowTypeError({"Type '", newInterface->Name(), "' recursively references itself as a base type"},
+                                    decl->AsInterfaceDecl()->Node()->AsTSInterfaceDeclaration()->Id()->Start());
+        }
+
+        checker::ObjectType *resolvedBaseType = InferType(checker, extendsVar)->AsObjectType();
+
+        if (extendsVar->HasFlag(binder::VariableFlags::INTERFACE)) {
+            for (const auto *it : extendsVar->Declaration()->AsInterfaceDecl()->Decls()) {
+                if (!it->TypeParams()) {
+                    continue;
+                }
+
+                resolvedBaseType = checker
+                                       ->InstantiateGenericInterface(extendsVar, extendsVar->Declaration(),
+                                                                     base->TypeParams(), base->Start())
+                                       ->AsObjectType();
+                break;
+            }
+        }
+
+        newInterface->AddBase(resolvedBaseType);
+
+        checker->TypeStack().erase(extendsVar->Declaration()->Node());
+    }
+
+    CheckInheritedPropertiesAreIdentical(checker, newInterface, declarations[0]->Id()->Start());
+
+    for (auto *it : newInterface->Bases()) {
+        checker->IsTypeAssignableTo(
+            newInterface, it,
+            {"Interface '", newInterface, "' incorrectly extends interface '", it->AsInterfaceType(), "'"},
+            declarations[0]->Start());
+    }
+
+    checker->CheckIndexConstraints(newInterface);
+
+    return newInterface;
+}
+
+checker::Type *TSInterfaceDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    if (!id_->Variable()->TsType()) {
+        InferType(checker, id_->Variable());
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsInterfaceDeclaration.h b/es2panda/ir/ts/tsInterfaceDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..e613ae1346177db6f56bed5b8ea1aafeb402af54
--- /dev/null
+++ b/es2panda/ir/ts/tsInterfaceDeclaration.h
@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_INTERFACE_DECLARATION_H
+#define ES2PANDA_IR_TS_INTERFACE_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::binder {
+class LocalScope;
+class Variable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+class TSInterfaceBody;
+class TSInterfaceHeritage;
+class TSTypeParameterDeclaration;
+
+class TSInterfaceDeclaration : public Statement {
+public:
+    explicit TSInterfaceDeclaration(binder::LocalScope *scope, Identifier *id, TSTypeParameterDeclaration *typeParams,
+                                    TSInterfaceBody *body, ArenaVector<TSInterfaceHeritage *> &&extends)
+        : Statement(AstNodeType::TS_INTERFACE_DECLARATION),
+          scope_(scope),
+          id_(id),
+          typeParams_(typeParams),
+          body_(body),
+          extends_(std::move(extends))
+    {
+    }
+
+    binder::LocalScope *Scope() const
+    {
+        return scope_;
+    }
+
+    const TSInterfaceBody *Body() const
+    {
+        return body_;
+    }
+
+    const Identifier *Id() const
+    {
+        return id_;
+    }
+
+    const TSTypeParameterDeclaration *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const ArenaVector<TSInterfaceHeritage *> &Extends() const
+    {
+        return extends_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+    checker::Type *InferType(checker::Checker *checker, binder::Variable *bindingVar) const;
+
+private:
+    binder::LocalScope *scope_;
+    Identifier *id_;
+    TSTypeParameterDeclaration *typeParams_;
+    TSInterfaceBody *body_;
+    ArenaVector<TSInterfaceHeritage *> extends_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsInterfaceHeritage.cpp b/es2panda/ir/ts/tsInterfaceHeritage.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..79d8e44b09a5a9184a2c3b6f0fbf59b1e9ec0906
--- /dev/null
+++ b/es2panda/ir/ts/tsInterfaceHeritage.cpp
@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsInterfaceHeritage.h"
+
+#include <binder/scope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+#include <ir/ts/tsTypeReference.h>
+
+namespace panda::es2panda::ir {
+
+void TSInterfaceHeritage::Iterate(const NodeTraverser &cb) const
+{
+    cb(expr_);
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+}
+
+void TSInterfaceHeritage::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add(
+        {{"type", "TSInterfaceHeritage"}, {"expression", expr_}, {"typeParameters", AstDumper::Optional(typeParams_)}});
+}
+
+void TSInterfaceHeritage::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSInterfaceHeritage::Check([[maybe_unused]] checker::Checker *checker) const
+{  // TODO(Csaba Repasi): Handle TSQualifiedName here
+    return TSTypeReference::ResolveReference(checker, expr_->AsIdentifier()->Variable(), expr_->AsIdentifier(),
+                                             nullptr);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsInterfaceHeritage.h b/es2panda/ir/ts/tsInterfaceHeritage.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb2a86d4fb7781f62639357473c8c42d8f405cc7
--- /dev/null
+++ b/es2panda/ir/ts/tsInterfaceHeritage.h
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_INTERFACE_HERITAGE_H
+#define ES2PANDA_IR_TS_INTERFACE_HERITAGE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+class TSTypeParameterInstantiation;
+
+class TSInterfaceHeritage : public Expression {
+public:
+    explicit TSInterfaceHeritage(Expression *expr, TSTypeParameterInstantiation *typeParams)
+        : Expression(AstNodeType::TS_INTERFACE_HERITAGE), expr_(expr), typeParams_(typeParams)
+    {
+    }
+
+    const Expression *Expr() const
+    {
+        return expr_;
+    }
+
+    const TSTypeParameterInstantiation *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expr_;
+    TSTypeParameterInstantiation *typeParams_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsIntersectionType.cpp b/es2panda/ir/ts/tsIntersectionType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..218a4fab4569405a82a347420e69f05e7f9372b3
--- /dev/null
+++ b/es2panda/ir/ts/tsIntersectionType.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsIntersectionType.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSIntersectionType::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : types_) {
+        cb(it);
+    }
+}
+
+void TSIntersectionType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSIntersectionType"}, {"types", types_}});
+}
+
+void TSIntersectionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSIntersectionType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsIntersectionType.h b/es2panda/ir/ts/tsIntersectionType.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a868f4f4de20b0b6378999f828742088fe4fc57
--- /dev/null
+++ b/es2panda/ir/ts/tsIntersectionType.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_INTERSECTION_TYPE_H
+#define ES2PANDA_IR_TS_INTERSECTION_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSIntersectionType : public Expression {
+public:
+    explicit TSIntersectionType(ArenaVector<Expression *> &&types)
+        : Expression(AstNodeType::TS_INTERSECTION_TYPE), types_(std::move(types))
+    {
+    }
+
+    const ArenaVector<Expression *> &Types() const
+    {
+        return types_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ArenaVector<Expression *> types_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsLiteralType.cpp b/es2panda/ir/ts/tsLiteralType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..14d0793a3dc55617ba40f6913ac2adbee9c18032
--- /dev/null
+++ b/es2panda/ir/ts/tsLiteralType.cpp
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsLiteralType.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSLiteralType::Iterate(const NodeTraverser &cb) const
+{
+    cb(literal_);
+}
+
+void TSLiteralType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSLiteralType"}, {"literal", literal_}});
+}
+
+void TSLiteralType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSLiteralType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsLiteralType.h b/es2panda/ir/ts/tsLiteralType.h
new file mode 100644
index 0000000000000000000000000000000000000000..49b89032b36c18824948f559e5ff327fcc1aaa8a
--- /dev/null
+++ b/es2panda/ir/ts/tsLiteralType.h
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_LITERAL_TYPE_H
+#define ES2PANDA_IR_TS_LITERAL_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSLiteralType : public Expression {
+public:
+    explicit TSLiteralType(Expression *literal) : Expression(AstNodeType::TS_LITERAL_TYPE), literal_(literal) {}
+
+    const Expression *Literal() const
+    {
+        return literal_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *literal_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsMappedType.cpp b/es2panda/ir/ts/tsMappedType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7be2950b1057f39ea839231201912c59ab1367bf
--- /dev/null
+++ b/es2panda/ir/ts/tsMappedType.cpp
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsMappedType.h"
+
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+
+namespace panda::es2panda::ir {
+
+void TSMappedType::Iterate(const NodeTraverser &cb) const
+{
+    cb(typeParameter_);
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+}
+
+void TSMappedType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add(
+        {{"type", "TSMappedType"},
+         {"typeParameter", typeParameter_},
+         {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+         {"readonly", readonly_ == MappedOption::NO_OPTS
+                          ? AstDumper::Optional(false)
+                          : readonly_ == MappedOption::PLUS ? AstDumper::Optional("+") : AstDumper::Optional("-")},
+         {"optional", optional_ == MappedOption::NO_OPTS
+                          ? AstDumper::Optional(false)
+                          : optional_ == MappedOption::PLUS ? AstDumper::Optional("+") : AstDumper::Optional("-")}});
+}
+
+void TSMappedType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSMappedType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsMappedType.h b/es2panda/ir/ts/tsMappedType.h
new file mode 100644
index 0000000000000000000000000000000000000000..6fe44032e2b9e37b5ad81b53d52d407289e2e475
--- /dev/null
+++ b/es2panda/ir/ts/tsMappedType.h
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_MAPPED_TYPE_H
+#define ES2PANDA_IR_TS_MAPPED_TYPE_H
+
+#include <ir/expression.h>
+#include <ir/ts/tsTypeParameter.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSMappedType : public Expression {
+public:
+    explicit TSMappedType(TSTypeParameter *typeParameter, Expression *typeAnnotation, MappedOption readonly,
+                          MappedOption optional)
+        : Expression(AstNodeType::TS_MAPPED_TYPE),
+          typeParameter_(typeParameter),
+          typeAnnotation_(typeAnnotation),
+          readonly_(readonly),
+          optional_(optional)
+    {
+    }
+
+    TSTypeParameter *TypeParameter()
+    {
+        return typeParameter_;
+    }
+
+    Expression *TypeAnnotation()
+    {
+        return typeAnnotation_;
+    }
+
+    MappedOption Readonly()
+    {
+        return readonly_;
+    }
+
+    MappedOption Optional()
+    {
+        return optional_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    TSTypeParameter *typeParameter_;
+    Expression *typeAnnotation_;
+    MappedOption readonly_;
+    MappedOption optional_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsMethodSignature.cpp b/es2panda/ir/ts/tsMethodSignature.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee83c851de19b6fc0bcfa5d32f7e62dfaef15960
--- /dev/null
+++ b/es2panda/ir/ts/tsMethodSignature.cpp
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsMethodSignature.h"
+
+#include <binder/scope.h>
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void TSMethodSignature::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    for (auto *it : params_) {
+        cb(it);
+    }
+
+    if (returnTypeAnnotation_) {
+        cb(returnTypeAnnotation_);
+    }
+}
+
+void TSMethodSignature::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSMethodSignature"},
+                 {"computed", computed_},
+                 {"optional", optional_},
+                 {"key", key_},
+                 {"params", params_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"typeAnnotation", AstDumper::Optional(returnTypeAnnotation_)}});
+}
+
+void TSMethodSignature::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSMethodSignature::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsMethodSignature.h b/es2panda/ir/ts/tsMethodSignature.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f13eb00b2187c3ea7ab8311df4ec7a52dab5738
--- /dev/null
+++ b/es2panda/ir/ts/tsMethodSignature.h
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_METHOD_SIGNATURE_H
+#define ES2PANDA_IR_TS_METHOD_SIGNATURE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::binder {
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterDeclaration;
+
+class TSMethodSignature : public Expression {
+public:
+    explicit TSMethodSignature(binder::Scope *scope, Expression *key, TSTypeParameterDeclaration *typeParams,
+                               ArenaVector<Expression *> &&params, Expression *returnTypeAnnotation, bool computed,
+                               bool optional)
+        : Expression(AstNodeType::TS_METHOD_SIGNATURE),
+          scope_(scope),
+          key_(key),
+          typeParams_(typeParams),
+          params_(std::move(params)),
+          returnTypeAnnotation_(returnTypeAnnotation),
+          computed_(computed),
+          optional_(optional)
+    {
+    }
+
+    binder::Scope *Scope() const
+    {
+        return scope_;
+    }
+
+    const Expression *Key() const
+    {
+        return key_;
+    }
+
+    const TSTypeParameterDeclaration *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const ArenaVector<Expression *> &Params() const
+    {
+        return params_;
+    }
+
+    const Expression *ReturnTypeAnnotation() const
+    {
+        return returnTypeAnnotation_;
+    }
+
+    bool Computed() const
+    {
+        return computed_;
+    }
+
+    bool Optional() const
+    {
+        return optional_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::Scope *scope_;
+    Expression *key_;
+    TSTypeParameterDeclaration *typeParams_;
+    ArenaVector<Expression *> params_;
+    Expression *returnTypeAnnotation_;
+    bool computed_;
+    bool optional_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsModuleBlock.cpp b/es2panda/ir/ts/tsModuleBlock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..295d18d207903b3ca708d114eade7ead85fccad5
--- /dev/null
+++ b/es2panda/ir/ts/tsModuleBlock.cpp
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsModuleBlock.h"
+
+#include <binder/scope.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSModuleBlock::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : statements_) {
+        cb(it);
+    }
+}
+
+void TSModuleBlock::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSModuleBlock"}, {"body", statements_}});
+}
+
+void TSModuleBlock::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSModuleBlock::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsModuleBlock.h b/es2panda/ir/ts/tsModuleBlock.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0c74c12d2de478624cf7802474a9d33820cbe72
--- /dev/null
+++ b/es2panda/ir/ts/tsModuleBlock.h
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_MODULE_BLOCK_H
+#define ES2PANDA_IR_TS_MODULE_BLOCK_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::binder {
+class LocalScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSModuleBlock : public Statement {
+public:
+    explicit TSModuleBlock(binder::LocalScope *scope, ArenaVector<Statement *> &&statements)
+        : Statement(AstNodeType::TS_MODULE_BLOCK), scope_(scope), statements_(std::move(statements))
+    {
+    }
+
+    binder::LocalScope *Scope() const
+    {
+        return scope_;
+    }
+
+    const ArenaVector<Statement *> &Statements() const
+    {
+        return statements_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::LocalScope *scope_;
+    ArenaVector<Statement *> statements_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsModuleDeclaration.cpp b/es2panda/ir/ts/tsModuleDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65667dd6ef996ff08c58ee2094a99bfc32e4ff8a
--- /dev/null
+++ b/es2panda/ir/ts/tsModuleDeclaration.cpp
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsModuleDeclaration.h"
+
+#include <binder/scope.h>
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void TSModuleDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(name_);
+
+    if (body_) {
+        cb(body_);
+    }
+}
+
+void TSModuleDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSModuleDeclaration"},
+                 {"id", name_},
+                 {"body", AstDumper::Optional(body_)},
+                 {"declare", declare_},
+                 {"global", global_}});
+}
+
+void TSModuleDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSModuleDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsModuleDeclaration.h b/es2panda/ir/ts/tsModuleDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc991c4d266800b4dde6b7fbc5bbce2ba4964321
--- /dev/null
+++ b/es2panda/ir/ts/tsModuleDeclaration.h
@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_MODULE_DECLARATION_H
+#define ES2PANDA_IR_TS_MODULE_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::binder {
+class LocalScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Expression;
+
+class TSModuleDeclaration : public Statement {
+public:
+    explicit TSModuleDeclaration(binder::LocalScope *scope, Expression *name, Statement *body, bool declare,
+                                 bool global)
+        : Statement(AstNodeType::TS_MODULE_DECLARATION),
+          scope_(scope),
+          name_(name),
+          body_(body),
+          declare_(declare),
+          global_(global)
+    {
+    }
+
+    binder::LocalScope *Scope() const
+    {
+        return scope_;
+    }
+
+    const Expression *Name() const
+    {
+        return name_;
+    }
+
+    const Statement *Body() const
+    {
+        return body_;
+    }
+
+    bool Declare() const
+    {
+        return declare_;
+    }
+
+    bool Global() const
+    {
+        return global_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::LocalScope *scope_;
+    Expression *name_;
+    Statement *body_;
+    bool declare_;
+    bool global_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsNamedTupleMember.cpp b/es2panda/ir/ts/tsNamedTupleMember.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..712e44530b6f2f58a74b40d7f9cb72d06fb940c1
--- /dev/null
+++ b/es2panda/ir/ts/tsNamedTupleMember.cpp
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsNamedTupleMember.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSNamedTupleMember::Iterate(const NodeTraverser &cb) const
+{
+    cb(label_);
+    cb(elementType_);
+}
+
+void TSNamedTupleMember::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSNamedTupleMember"},
+                 {"elementType", elementType_},
+                 {"label", label_},
+                 {"optional", AstDumper::Optional(optional_)}});
+}
+
+void TSNamedTupleMember::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSNamedTupleMember::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsNamedTupleMember.h b/es2panda/ir/ts/tsNamedTupleMember.h
new file mode 100644
index 0000000000000000000000000000000000000000..8881cd48527709d56e4862e79bd2919f17d5b736
--- /dev/null
+++ b/es2panda/ir/ts/tsNamedTupleMember.h
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_NAMED_TUPLE_MEMBER_TYPE_H
+#define ES2PANDA_IR_TS_NAMED_TUPLE_MEMBER_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSNamedTupleMember : public Expression {
+public:
+    explicit TSNamedTupleMember(Expression *label, Expression *elementType, bool optional)
+        : Expression(AstNodeType::TS_NAMED_TUPLE_MEMBER),
+          label_(label),
+          elementType_(elementType),
+          optional_(optional)
+    {
+    }
+
+    const Expression *Label() const
+    {
+        return label_;
+    }
+
+    const Expression *ElementType() const
+    {
+        return elementType_;
+    }
+
+    bool IsOptional() const
+    {
+        return optional_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *label_;
+    Expression *elementType_;
+    bool optional_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsNeverKeyword.cpp b/es2panda/ir/ts/tsNeverKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c81caf32e3f217f30439f11a5d611608e871b597
--- /dev/null
+++ b/es2panda/ir/ts/tsNeverKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsNeverKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSNeverKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSNeverKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSNeverKeyword"}});
+}
+
+void TSNeverKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSNeverKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsNeverKeyword.h b/es2panda/ir/ts/tsNeverKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5bbd21a861e27d1aebb048ceecbc0cff07e300c
--- /dev/null
+++ b/es2panda/ir/ts/tsNeverKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_NEVER_KEYWORD_H
+#define ES2PANDA_IR_TS_NEVER_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSNeverKeyword : public Expression {
+public:
+    explicit TSNeverKeyword() : Expression(AstNodeType::TS_NEVER_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsNonNullExpression.cpp b/es2panda/ir/ts/tsNonNullExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..23fad238df8b09268e3497f8e6265425ca2161b0
--- /dev/null
+++ b/es2panda/ir/ts/tsNonNullExpression.cpp
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsNonNullExpression.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSNonNullExpression::Iterate([[maybe_unused]] const NodeTraverser &cb) const
+{
+    cb(expr_);
+}
+
+void TSNonNullExpression::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSNonNullExpression"}, {"expression", expr_}});
+}
+
+void TSNonNullExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSNonNullExpression::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsNonNullExpression.h b/es2panda/ir/ts/tsNonNullExpression.h
new file mode 100644
index 0000000000000000000000000000000000000000..110a3174ef835afcc727fb1cd428c02835653bab
--- /dev/null
+++ b/es2panda/ir/ts/tsNonNullExpression.h
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_NON_NULL_EXPRESSION_H
+#define ES2PANDA_IR_TS_NON_NULL_EXPRESSION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSNonNullExpression : public Expression {
+public:
+    explicit TSNonNullExpression(Expression *expr) : Expression(AstNodeType::TS_NON_NULL_EXPRESSION), expr_(expr) {}
+
+    const Expression *Expr() const
+    {
+        return expr_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *expr_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsNullKeyword.cpp b/es2panda/ir/ts/tsNullKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b5300a279dbf58bfc40966a7b8b97c3332acfdd5
--- /dev/null
+++ b/es2panda/ir/ts/tsNullKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsNullKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSNullKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSNullKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSNullKeyword"}});
+}
+
+void TSNullKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSNullKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsNullKeyword.h b/es2panda/ir/ts/tsNullKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..065c13a4998c4b4944ebc92bb5dd88e8fd337150
--- /dev/null
+++ b/es2panda/ir/ts/tsNullKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_NULL_KEYWORD_H
+#define ES2PANDA_IR_TS_NULL_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSNullKeyword : public Expression {
+public:
+    explicit TSNullKeyword() : Expression(AstNodeType::TS_NULL_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsNumberKeyword.cpp b/es2panda/ir/ts/tsNumberKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f9b1f79f13d12a7ff7cdc8b1285e305492f16750
--- /dev/null
+++ b/es2panda/ir/ts/tsNumberKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsNumberKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSNumberKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSNumberKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSNumberKeyword"}});
+}
+
+void TSNumberKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSNumberKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsNumberKeyword.h b/es2panda/ir/ts/tsNumberKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..48e7687c1300d665af79d207af77209068460e27
--- /dev/null
+++ b/es2panda/ir/ts/tsNumberKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_NUMBER_KEYWORD_H
+#define ES2PANDA_IR_TS_NUMBER_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSNumberKeyword : public Expression {
+public:
+    explicit TSNumberKeyword() : Expression(AstNodeType::TS_NUMBER_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsObjectKeyword.cpp b/es2panda/ir/ts/tsObjectKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e7836f1ef9a57efd71a8b592fc56b8e41f39d39
--- /dev/null
+++ b/es2panda/ir/ts/tsObjectKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsObjectKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSObjectKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSObjectKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSObjectKeyword"}});
+}
+
+void TSObjectKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSObjectKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsObjectKeyword.h b/es2panda/ir/ts/tsObjectKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..66c4499eee2fef3509e68586b069a2813d48f92a
--- /dev/null
+++ b/es2panda/ir/ts/tsObjectKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_OBJECT_KEYWORD_H
+#define ES2PANDA_IR_TS_OBJECT_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSObjectKeyword : public Expression {
+public:
+    explicit TSObjectKeyword() : Expression(AstNodeType::TS_OBJECT_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsParameterProperty.cpp b/es2panda/ir/ts/tsParameterProperty.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a1583d5a6a8d75887c2355684e9fd37c00ad3916
--- /dev/null
+++ b/es2panda/ir/ts/tsParameterProperty.cpp
@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsParameterProperty.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+void TSParameterProperty::Iterate(const NodeTraverser &cb) const
+{
+    cb(parameter_);
+}
+
+void TSParameterProperty::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add(
+        {{"type", "TSParameterProperty"},
+         {"accessibility", accessibility_ == AccessibilityOption::PUBLIC
+                               ? "public"
+                               : accessibility_ == AccessibilityOption::PRIVATE
+                                     ? "private"
+                                     : accessibility_ == AccessibilityOption::PROTECTED ? "protected" : "undefined"},
+         {"readonly", readonly_},
+         {"static", static_},
+         {"export", export_},
+         {"parameter", parameter_}});
+}
+
+void TSParameterProperty::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSParameterProperty::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsParameterProperty.h b/es2panda/ir/ts/tsParameterProperty.h
new file mode 100644
index 0000000000000000000000000000000000000000..635ec0a45523ce68e517b17b03c473263d138584
--- /dev/null
+++ b/es2panda/ir/ts/tsParameterProperty.h
@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_PARAMETER_PROPERTY_H
+#define ES2PANDA_IR_TS_PARAMETER_PROPERTY_H
+
+#include <ir/expression.h>
+#include <lexer/token/tokenType.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+enum class AccessibilityOption { NO_OPTS, PUBLIC, PRIVATE, PROTECTED };
+
+class TSParameterProperty : public Expression {
+public:
+    explicit TSParameterProperty(AccessibilityOption accessibility, Expression *parameter, bool readonly,
+                                 bool isStatic, bool isExport)
+        : Expression(AstNodeType::TS_PARAMETER_PROPERTY),
+          accessibility_(accessibility),
+          parameter_(parameter),
+          readonly_(readonly),
+          static_(isStatic),
+          export_(isExport)
+    {
+    }
+
+    AccessibilityOption Accessibility() const
+    {
+        return accessibility_;
+    }
+
+    bool Readonly() const
+    {
+        return readonly_;
+    }
+
+    bool IsStatic() const
+    {
+        return static_;
+    }
+
+    bool IsExport() const
+    {
+        return export_;
+    }
+
+    const Expression *Parameter() const
+    {
+        return parameter_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    AccessibilityOption accessibility_;
+    Expression *parameter_;
+    bool readonly_;
+    bool static_;
+    bool export_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsParenthesizedType.cpp b/es2panda/ir/ts/tsParenthesizedType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..577d4ea4da72e327714b879ff61a9b23cd94d05a
--- /dev/null
+++ b/es2panda/ir/ts/tsParenthesizedType.cpp
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsParenthesizedType.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSParenthesizedType::Iterate(const NodeTraverser &cb) const
+{
+    cb(type_);
+}
+
+void TSParenthesizedType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSParenthesizedType"}, {"typeAnnotation", type_}});
+}
+
+void TSParenthesizedType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSParenthesizedType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsParenthesizedType.h b/es2panda/ir/ts/tsParenthesizedType.h
new file mode 100644
index 0000000000000000000000000000000000000000..1fd0031d9851c8262b58fcff363ecc56809e8517
--- /dev/null
+++ b/es2panda/ir/ts/tsParenthesizedType.h
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_PARENT_TYPE_H
+#define ES2PANDA_IR_TS_PARENT_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSParenthesizedType : public Expression {
+public:
+    explicit TSParenthesizedType(Expression *type) : Expression(AstNodeType::TS_PARENT_TYPE), type_(type) {}
+
+    const Expression *Type() const
+    {
+        return type_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *type_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsPrivateIdentifier.cpp b/es2panda/ir/ts/tsPrivateIdentifier.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e510353450b25df865893eea233bd3f825a860c2
--- /dev/null
+++ b/es2panda/ir/ts/tsPrivateIdentifier.cpp
@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsPrivateIdentifier.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSPrivateIdentifier::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+
+    if (value_) {
+        cb(value_);
+    }
+
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+}
+
+void TSPrivateIdentifier::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSPrivateIdentifier"},
+                 {"key", key_},
+                 {"value", AstDumper::Optional(value_)},
+                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
+}
+
+void TSPrivateIdentifier::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSPrivateIdentifier::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsPrivateIdentifier.h b/es2panda/ir/ts/tsPrivateIdentifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4872d5a8f204e60e4b10b25b0908693cd81dfe5
--- /dev/null
+++ b/es2panda/ir/ts/tsPrivateIdentifier.h
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_PRIVATE_IDENTIFIER_H
+#define ES2PANDA_IR_TS_PRIVATE_IDENTIFIER_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSPrivateIdentifier : public Expression {
+public:
+    explicit TSPrivateIdentifier(Expression *key, Expression *value, Expression *typeAnnotation)
+        : Expression(AstNodeType::TS_PRIVATE_IDENTIFIER), key_(key), value_(value), typeAnnotation_(typeAnnotation)
+    {
+    }
+
+    const Expression *Key() const
+    {
+        return key_;
+    }
+
+    const Expression *Value() const
+    {
+        return value_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *key_;
+    Expression *value_;
+    Expression *typeAnnotation_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsPropertySignature.cpp b/es2panda/ir/ts/tsPropertySignature.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e91a37a8785ba74c584677e0a95f6984fb42ccd
--- /dev/null
+++ b/es2panda/ir/ts/tsPropertySignature.cpp
@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsPropertySignature.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSPropertySignature::Iterate(const NodeTraverser &cb) const
+{
+    cb(key_);
+
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+}
+
+void TSPropertySignature::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSPropertySignature"},
+                 {"computed", computed_},
+                 {"optional", optional_},
+                 {"readonly", readonly_},
+                 {"key", key_},
+                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
+}
+
+void TSPropertySignature::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSPropertySignature::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsPropertySignature.h b/es2panda/ir/ts/tsPropertySignature.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b9b9a068c69b53d7aeb69d596704acefd0d89b6
--- /dev/null
+++ b/es2panda/ir/ts/tsPropertySignature.h
@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_PROPERTY_SIGNATURE_H
+#define ES2PANDA_IR_TS_PROPERTY_SIGNATURE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSPropertySignature : public Expression {
+public:
+    explicit TSPropertySignature(Expression *key, Expression *typeAnnotation, bool computed, bool optional,
+                                 bool readonly)
+        : Expression(AstNodeType::TS_PROPERTY_SIGNATURE),
+          key_(key),
+          typeAnnotation_(typeAnnotation),
+          computed_(computed),
+          optional_(optional),
+          readonly_(readonly)
+    {
+    }
+
+    const Expression *Key() const
+    {
+        return key_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    bool Computed() const
+    {
+        return computed_;
+    }
+
+    bool Optional() const
+    {
+        return optional_;
+    }
+
+    bool Readonly() const
+    {
+        return readonly_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *key_;
+    Expression *typeAnnotation_;
+    bool computed_;
+    bool optional_;
+    bool readonly_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsQualifiedName.cpp b/es2panda/ir/ts/tsQualifiedName.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6208a27971a16beadee045a9241def8b63f5068
--- /dev/null
+++ b/es2panda/ir/ts/tsQualifiedName.cpp
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsQualifiedName.h"
+
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void TSQualifiedName::Iterate(const NodeTraverser &cb) const
+{
+    cb(left_);
+    cb(right_);
+}
+
+void TSQualifiedName::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSQualifiedName"}, {"left", left_}, {"right", right_}});
+}
+
+void TSQualifiedName::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSQualifiedName::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    checker::Type *baseType = left_->Check(checker);
+
+    if (!parent_->IsTSQualifiedName()) {
+        if (!checker->TypeStack().insert(right_).second) {
+            checker->ThrowTypeError({"'", checker->ToPropertyName(right_, checker::TypeFlag::COMPUTED_NAME),
+                                     "' is referenced directly or indirectly in its own type annotation."},
+                                    right_->Start());
+        }
+    }
+
+    checker::Type *propType = checker->ResolveBaseProp(baseType, right_, false, Start());
+
+    checker->TypeStack().erase(right_);
+
+    if (!parent_->IsTSIndexedAccessType() || !parent_->IsTSQualifiedName()) {
+        const ir::TSQualifiedName *leftMost = checker::Checker::ResolveLeftMostQualifiedName(this);
+
+        const util::StringView &objName = leftMost->Left()->AsIdentifier()->Name();
+        const util::StringView &propName = leftMost->Right()->Name();
+        checker->ThrowTypeError(
+            {"Cannot access '", objName, ".", propName, "' because '", objName,
+             "' is a type, but not a namespace. Did you mean to retrieve the type of the property '", propName,
+             "' in '", objName, "' with '", objName, "[\"", propName, "\"]'?"},
+            Start());
+    }
+
+    return propType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsQualifiedName.h b/es2panda/ir/ts/tsQualifiedName.h
new file mode 100644
index 0000000000000000000000000000000000000000..2eb2029508ced799e20bdeab3efca52dc3e4cf5b
--- /dev/null
+++ b/es2panda/ir/ts/tsQualifiedName.h
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_QUALIFIED_NAME_H
+#define ES2PANDA_IR_TS_QUALIFIED_NAME_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSQualifiedName : public Expression {
+public:
+    explicit TSQualifiedName(Expression *left, Identifier *right)
+        : Expression(AstNodeType::TS_QUALIFIED_NAME), left_(left), right_(right)
+    {
+    }
+
+    const Expression *Left() const
+    {
+        return left_;
+    }
+
+    const Identifier *Right() const
+    {
+        return right_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *left_;
+    Identifier *right_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsSignatureDeclaration.cpp b/es2panda/ir/ts/tsSignatureDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1269e945c29a29870dfad48ad51ee8e9f99c4815
--- /dev/null
+++ b/es2panda/ir/ts/tsSignatureDeclaration.cpp
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsSignatureDeclaration.h"
+
+#include <binder/scope.h>
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void TSSignatureDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    for (auto *it : params_) {
+        cb(it);
+    }
+
+    if (returnTypeAnnotation_) {
+        cb(returnTypeAnnotation_);
+    }
+}
+
+void TSSignatureDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", (kind_ == TSSignatureDeclaration::TSSignatureDeclarationKind::CALL_SIGNATURE)
+                              ? "TSCallSignatureDeclaration"
+                              : "TSConstructSignatureDeclaration"},
+                 {"params", params_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"returnType", AstDumper::Optional(returnTypeAnnotation_)}});
+}
+
+void TSSignatureDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSSignatureDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsSignatureDeclaration.h b/es2panda/ir/ts/tsSignatureDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..15ba36862ee623f6471b14490308d8a7465cc151
--- /dev/null
+++ b/es2panda/ir/ts/tsSignatureDeclaration.h
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_SIGNATURE_DECLARATION_H
+#define ES2PANDA_IR_TS_SIGNATURE_DECLARATION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::binder {
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterDeclaration;
+
+class TSSignatureDeclaration : public Expression {
+public:
+    enum class TSSignatureDeclarationKind { CALL_SIGNATURE, CONSTRUCT_SIGNATURE };
+
+    explicit TSSignatureDeclaration(binder::Scope *scope, TSSignatureDeclarationKind kind,
+                                    TSTypeParameterDeclaration *typeParams,
+                                    ArenaVector<Expression *> &&params, Expression *returnTypeAnnotation)
+        : Expression(AstNodeType::TS_SIGNATURE_DECLARATION),
+          scope_(scope),
+          kind_(kind),
+          typeParams_(typeParams),
+          params_(std::move(params)),
+          returnTypeAnnotation_(returnTypeAnnotation)
+    {
+    }
+    binder::Scope *Scope() const
+    {
+        return scope_;
+    }
+
+    const TSTypeParameterDeclaration *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const ArenaVector<Expression *> &Params() const
+    {
+        return params_;
+    }
+
+    const Expression *ReturnTypeAnnotation() const
+    {
+        return returnTypeAnnotation_;
+    }
+
+    TSSignatureDeclarationKind Kind() const
+    {
+        return kind_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::Scope *scope_;
+    TSSignatureDeclarationKind kind_;
+    TSTypeParameterDeclaration *typeParams_;
+    ArenaVector<Expression *> params_;
+    Expression *returnTypeAnnotation_;
+};
+
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsStringKeyword.cpp b/es2panda/ir/ts/tsStringKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f321d774ad16f3fefb38d71b52031d56e248bc7e
--- /dev/null
+++ b/es2panda/ir/ts/tsStringKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsStringKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSStringKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSStringKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSStringKeyword"}});
+}
+
+void TSStringKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSStringKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsStringKeyword.h b/es2panda/ir/ts/tsStringKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..a58f0b2e8c3c0c97598f217077b7773198390cd1
--- /dev/null
+++ b/es2panda/ir/ts/tsStringKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_STRING_KEYWORD_H
+#define ES2PANDA_IR_TS_STRING_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSStringKeyword : public Expression {
+public:
+    explicit TSStringKeyword() : Expression(AstNodeType::TS_STRING_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsThisType.cpp b/es2panda/ir/ts/tsThisType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4dbeaa57b40a88ec0e13de8cc5e5d260f846fc8
--- /dev/null
+++ b/es2panda/ir/ts/tsThisType.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsThisType.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSThisType::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSThisType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSThisType"}});
+}
+
+void TSThisType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSThisType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsThisType.h b/es2panda/ir/ts/tsThisType.h
new file mode 100644
index 0000000000000000000000000000000000000000..afda3d99e8b54dcbe415d6a82afe41dd16f10878
--- /dev/null
+++ b/es2panda/ir/ts/tsThisType.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_THIS_TYPE_H
+#define ES2PANDA_IR_TS_THIS_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSThisType : public Expression {
+public:
+    explicit TSThisType() : Expression(AstNodeType::TS_THIS_TYPE) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTupleType.cpp b/es2panda/ir/ts/tsTupleType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb835d731eb08f9b4f39cb4fdd3ed9c2680d6ea1
--- /dev/null
+++ b/es2panda/ir/ts/tsTupleType.cpp
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTupleType.h"
+
+#include <util/helpers.h>
+#include <binder/scope.h>
+#include <typescript/checker.h>
+#include <typescript/types/indexInfo.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/ts/tsNamedTupleMember.h>
+
+namespace panda::es2panda::ir {
+
+void TSTupleType::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : elementTypes_) {
+        cb(it);
+    }
+}
+
+void TSTupleType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTupleType"}, {"elementTypes", elementTypes_}});
+}
+
+void TSTupleType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTupleType::Check(checker::Checker *checker) const
+{
+    checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+    checker::NamedTupleMemberPool namedMembers;
+    checker::TupleElementFlagPool elementFlags;
+    checker::ElementFlags combinedFlags = checker::ElementFlags::NO_OPTS;
+    uint32_t minLength = 0;
+    uint32_t index = 0;
+    std::vector<checker::Type *> numberIndexTypes;
+    for (auto *it : elementTypes_) {
+        util::StringView memberIndex = util::Helpers::ToStringView(checker->Allocator(), index);
+
+        auto *memberVar =
+            binder::Scope::CreateVar(checker->Allocator(), memberIndex, binder::VariableFlags::PROPERTY, it);
+
+        checker::ElementFlags memberFlag = checker::ElementFlags::NO_OPTS;
+        if (it->IsTSNamedTupleMember()) {
+            const ir::TSNamedTupleMember *namedMember = it->AsTSNamedTupleMember();
+            checker::Type *memberType = namedMember->ElementType()->Check(checker);
+
+            if (namedMember->IsOptional()) {
+                memberVar->AddFlag(binder::VariableFlags::OPTIONAL);
+                memberFlag = checker::ElementFlags::OPTIONAL;
+            } else {
+                memberFlag = checker::ElementFlags::REQUIRED;
+                minLength++;
+            }
+
+            memberType->SetVariable(memberVar);
+            memberVar->SetTsType(memberType);
+            numberIndexTypes.push_back(memberType);
+            namedMembers.insert({memberVar, namedMember->Label()->AsIdentifier()->Name()});
+        } else {
+            checker::Type *memberType = it->Check(checker);
+            memberType->SetVariable(memberVar);
+            memberVar->SetTsType(memberType);
+            memberFlag = checker::ElementFlags::REQUIRED;
+            numberIndexTypes.push_back(memberType);
+            minLength++;
+        }
+
+        combinedFlags |= memberFlag;
+
+        elementFlags.insert({memberIndex, memberFlag});
+        desc->properties.push_back(memberVar);
+        index++;
+    }
+
+    uint32_t fixedLength = desc->properties.size();
+
+    checker::Type *numberIndexType = nullptr;
+
+    if (numberIndexTypes.empty()) {
+        numberIndexType = checker->GlobalNeverType();
+    } else if (numberIndexTypes.size() == 1) {
+        numberIndexType = numberIndexTypes[0];
+    } else {
+        numberIndexType = checker->CreateUnionType(std::move(numberIndexTypes));
+    }
+
+    desc->numberIndexInfo = checker->Allocator()->New<checker::IndexInfo>(numberIndexType, "x");
+
+    return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength, false,
+                                    std::move(namedMembers));
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTupleType.h b/es2panda/ir/ts/tsTupleType.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e7adec0796b5f5cc08db0b6132903604547f42b
--- /dev/null
+++ b/es2panda/ir/ts/tsTupleType.h
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TUPLE_TYPE_H
+#define ES2PANDA_IR_TS_TUPLE_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+enum class TSTupleKind { NONE, NAMED, DEFAULT };
+
+class TSTupleType : public Expression {
+public:
+    explicit TSTupleType(ArenaVector<Expression *> &&elementTypes)
+        : Expression(AstNodeType::TS_TUPLE_TYPE), elementTypes_(std::move(elementTypes))
+    {
+    }
+
+    const ArenaVector<Expression *> &ElementType() const
+    {
+        return elementTypes_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ArenaVector<Expression *> elementTypes_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeAliasDeclaration.cpp b/es2panda/ir/ts/tsTypeAliasDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48b95901e2fb7a8f631f70342f7bfa84ae6f8d5b
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeAliasDeclaration.cpp
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeAliasDeclaration.h"
+
+#include <binder/scope.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeAliasDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    cb(id_);
+
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    cb(typeAnnotation_);
+}
+
+void TSTypeAliasDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTypeAliasDeclaration"},
+                 {"id", id_},
+                 {"typeAnnotation", typeAnnotation_},
+                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"declare", AstDumper::Optional(declare_)}});
+}
+
+void TSTypeAliasDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeAliasDeclaration::CheckTypeAnnotation(checker::Checker *checker,
+                                                           binder::Variable *bindingVar) const
+{
+    checker::Type *aliasType = typeAnnotation_->Check(checker);
+    aliasType->SetVariable(bindingVar);
+    bindingVar->SetTsType(aliasType);
+
+    return bindingVar->TsType();
+}
+
+checker::Type *TSTypeAliasDeclaration::InferType(checker::Checker *checker, binder::Variable *bindingVar) const
+{
+    if (typeParams_) {
+        checker::ScopeContext scopeCtx(checker, typeParams_->Scope());
+        checker->CheckTypeParameters(typeParams_);
+        return CheckTypeAnnotation(checker, bindingVar);
+    }
+
+    return CheckTypeAnnotation(checker, bindingVar);
+}
+
+checker::Type *TSTypeAliasDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    const util::StringView &aliasName = id_->Name();
+    binder::ScopeFindResult result = checker->Scope()->Find(aliasName);
+    ASSERT(result.variable);
+
+    if (!result.variable->TsType()) {
+        InferType(checker, result.variable);
+    }
+
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeAliasDeclaration.h b/es2panda/ir/ts/tsTypeAliasDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d28ef0ed23d39662373e12f448719f0c719019c
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeAliasDeclaration.h
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_ALIAS_DECLARATION_H
+#define ES2PANDA_IR_TS_TYPE_ALIAS_DECLARATION_H
+
+#include <ir/statement.h>
+
+namespace panda::es2panda::binder {
+class Variable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+class TSTypeParameterDeclaration;
+
+class TSTypeAliasDeclaration : public Statement {
+public:
+    explicit TSTypeAliasDeclaration(Identifier *id, TSTypeParameterDeclaration *typeParams,
+                                    Expression *typeAnnotation, bool declare)
+        : Statement(AstNodeType::TS_TYPE_ALIAS_DECLARATION),
+          id_(id),
+          typeParams_(typeParams),
+          typeAnnotation_(typeAnnotation),
+          declare_(declare)
+    {
+    }
+
+    const Identifier *Id() const
+    {
+        return id_;
+    }
+
+    const TSTypeParameterDeclaration *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    bool Declare() const
+    {
+        return declare_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+    checker::Type *InferType(checker::Checker *checker, binder::Variable *bindingVar) const;
+
+private:
+    checker::Type *CheckTypeAnnotation(checker::Checker *checker, binder::Variable *bindingVar) const;
+
+    Identifier *id_;
+    TSTypeParameterDeclaration *typeParams_;
+    Expression *typeAnnotation_;
+    bool declare_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeAssertion.cpp b/es2panda/ir/ts/tsTypeAssertion.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90ed300678e3ac304d9615a42eb94d2c4a440f2f
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeAssertion.cpp
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeAssertion.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeAssertion::Iterate(const NodeTraverser &cb) const
+{
+    cb(typeAnnotation_);
+    cb(expression_);
+}
+
+void TSTypeAssertion::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTypeAssertion"}, {"typeAnnotation", typeAnnotation_}, {"expression", expression_}});
+}
+
+void TSTypeAssertion::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeAssertion::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeAssertion.h b/es2panda/ir/ts/tsTypeAssertion.h
new file mode 100644
index 0000000000000000000000000000000000000000..d23ba49630adf3e0007e682d4733cdcd405898f9
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeAssertion.h
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_ASSERTION_H
+#define ES2PANDA_IR_TS_TYPE_ASSERTION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeAssertion : public Expression {
+public:
+    explicit TSTypeAssertion(Expression *typeAnnotation, Expression *expression)
+        : Expression(AstNodeType::TS_TYPE_ASSERTION), typeAnnotation_(typeAnnotation), expression_(expression)
+    {
+    }
+
+    const Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    const Expression *GetExpression() const
+    {
+        return expression_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *typeAnnotation_;
+    Expression *expression_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeLiteral.cpp b/es2panda/ir/ts/tsTypeLiteral.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe4dd561f9b8251b6ac9040397c74b85607a47fd
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeLiteral.cpp
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeLiteral.h"
+
+#include <ir/astDump.h>
+
+#include <binder/variable.h>
+#include <binder/declaration.h>
+#include <typescript/checker.h>
+#include <typescript/types/signature.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeLiteral::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : members_) {
+        cb(it);
+    }
+}
+
+void TSTypeLiteral::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTypeLiteral"}, {"members", members_}});
+}
+
+void TSTypeLiteral::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeLiteral::Check(checker::Checker *checker) const
+{
+    // TODO(aszilagyi): came from param
+    binder::Variable *bindingVar = nullptr;
+
+    checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+    checker::Type *returnType = checker->Allocator()->New<checker::ObjectLiteralType>(desc);
+
+    checker::Type *savedType = nullptr;
+
+    if (bindingVar) {
+        if (bindingVar->TsType()) {
+            savedType = bindingVar->TsType();
+        }
+
+        bindingVar->SetTsType(returnType);
+    }
+
+    for (auto *it : members_) {
+        if (it->IsTSPropertySignature() || it->IsTSMethodSignature()) {
+            checker->PrefetchTypeLiteralProperties(it, desc);
+        }
+    }
+
+    for (auto *it : members_) {
+        checker->CheckTsTypeLiteralOrInterfaceMember(it, desc);
+    }
+
+    if (bindingVar) {
+        if (savedType) {
+            checker->IsTypeIdenticalTo(savedType, bindingVar->TsType(),
+                                       {"Subsequent variable declaration must have the same type. Variable '",
+                                        bindingVar->Name(), "' must be of type '", savedType, "', but here has type '",
+                                        bindingVar->TsType(), "'."},
+                                       bindingVar->Declaration()->Node()->Start());
+        }
+    }
+
+    checker->CheckIndexConstraints(returnType);
+
+    return returnType;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeLiteral.h b/es2panda/ir/ts/tsTypeLiteral.h
new file mode 100644
index 0000000000000000000000000000000000000000..006024f7f13e1dca34175f4b8a12ca983802f7a0
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeLiteral.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_LITERAL_H
+#define ES2PANDA_IR_TS_TYPE_LITERAL_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeLiteral : public Expression {
+public:
+    explicit TSTypeLiteral(ArenaVector<Expression *> &&members)
+        : Expression(AstNodeType::TS_TYPE_LITERAL), members_(std::move(members))
+    {
+    }
+
+    const ArenaVector<Expression *> &Members() const
+    {
+        return members_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ArenaVector<Expression *> members_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeOperator.cpp b/es2panda/ir/ts/tsTypeOperator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd17dba1a2ec89064d61449d2c276a26aa3fe702
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeOperator.cpp
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeOperator.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeOperator::Iterate(const NodeTraverser &cb) const
+{
+    cb(type_);
+}
+
+void TSTypeOperator::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({
+        {"type", "TSTypeOperator"},
+        {"operator", AstDumper::TypeOperatorToString(operatorType_)},
+        {"typeAnnotation", type_},
+    });
+}
+
+void TSTypeOperator::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeOperator::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeOperator.h b/es2panda/ir/ts/tsTypeOperator.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cbefb6332ea528f4f376304a4bf7a59990a76d6
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeOperator.h
@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_OPERATOR_H
+#define ES2PANDA_IR_TS_TYPE_OPERATOR_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeOperator : public Expression {
+public:
+    explicit TSTypeOperator(Expression *type, TSOperatorType operatorType)
+        : Expression(AstNodeType::TS_TYPE_OPERATOR), type_(type), operatorType_(operatorType)
+    {
+    }
+
+    const Expression *Type() const
+    {
+        return type_;
+    }
+
+    bool IsReadonly() const
+    {
+        return operatorType_ == TSOperatorType::READONLY;
+    }
+
+    bool IsKeyof() const
+    {
+        return operatorType_ == TSOperatorType::KEYOF;
+    }
+
+    bool IsUnique() const
+    {
+        return operatorType_ == TSOperatorType::UNIQUE;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *type_;
+    TSOperatorType operatorType_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeParameter.cpp b/es2panda/ir/ts/tsTypeParameter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..462c53bb2e81664243f11010fbedcdca7c7dde3e
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeParameter.cpp
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeParameter.h"
+
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeParameter::Iterate(const NodeTraverser &cb) const
+{
+    cb(name_);
+
+    if (constraint_) {
+        cb(constraint_);
+    }
+
+    if (defaultType_) {
+        cb(defaultType_);
+    }
+}
+
+void TSTypeParameter::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({
+        {"type", "TSTypeParameter"},
+        {"name", name_},
+        {"constraint", AstDumper::Optional(constraint_)},
+        {"default", AstDumper::Optional(defaultType_)},
+    });
+}
+
+void TSTypeParameter::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeParameter::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeParameter.h b/es2panda/ir/ts/tsTypeParameter.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb6d2c0331bb61a4a20e27721e09a1193941d520
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeParameter.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_PARAMETER_H
+#define ES2PANDA_IR_TS_TYPE_PARAMETER_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class Identifier;
+
+class TSTypeParameter : public Expression {
+public:
+    explicit TSTypeParameter(Identifier *name, Expression *constraint, Expression *defaultType)
+        : Expression(AstNodeType::TS_TYPE_PARAMETER), name_(name), constraint_(constraint), defaultType_(defaultType)
+    {
+    }
+
+    const Identifier *Name() const
+    {
+        return name_;
+    }
+
+    const Expression *Constraint() const
+    {
+        return constraint_;
+    }
+
+    const Expression *DefaultType() const
+    {
+        return defaultType_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Identifier *name_;
+    Expression *constraint_;
+    Expression *defaultType_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeParameterDeclaration.cpp b/es2panda/ir/ts/tsTypeParameterDeclaration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7b2e868caa442f1f5c0e7aaf8343b8f463825cf3
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeParameterDeclaration.cpp
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeParameterDeclaration.h"
+
+#include <binder/scope.h>
+#include <ir/astDump.h>
+#include <ir/ts/tsTypeParameter.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeParameterDeclaration::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : params_) {
+        cb(it);
+    }
+}
+
+void TSTypeParameterDeclaration::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTypeParameterDeclaration"}, {"params", params_}});
+}
+
+void TSTypeParameterDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeParameterDeclaration::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeParameterDeclaration.h b/es2panda/ir/ts/tsTypeParameterDeclaration.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8b09540b6bbc9e2dbcda5c76e6d883357620922
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeParameterDeclaration.h
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_PARAMETER_DECLARATION_H
+#define ES2PANDA_IR_TS_TYPE_PARAMETER_DECLARATION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::binder {
+class LocalScope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameter;
+
+class TSTypeParameterDeclaration : public Expression {
+public:
+    explicit TSTypeParameterDeclaration(binder::LocalScope *scope, ArenaVector<TSTypeParameter *> &&params,
+                                        size_t requiredParams)
+        : Expression(AstNodeType::TS_TYPE_PARAMETER_DECLARATION),
+          scope_(scope),
+          params_(std::move(params)),
+          requiredParams_(requiredParams)
+    {
+    }
+
+    binder::LocalScope *Scope() const
+    {
+        return scope_;
+    }
+
+    const ArenaVector<TSTypeParameter *> &Params() const
+    {
+        return params_;
+    }
+
+    size_t RequiredParams() const
+    {
+        return requiredParams_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    binder::LocalScope *scope_;
+    ArenaVector<TSTypeParameter *> params_;
+    size_t requiredParams_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeParameterInstantiation.cpp b/es2panda/ir/ts/tsTypeParameterInstantiation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5910cfbc0025010556464563748d00f127c977a1
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeParameterInstantiation.cpp
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeParameterInstantiation.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeParameterInstantiation::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : params_) {
+        cb(it);
+    }
+}
+
+void TSTypeParameterInstantiation::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTypeParameterInstantiation"}, {"params", params_}});
+}
+
+void TSTypeParameterInstantiation::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeParameterInstantiation::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeParameterInstantiation.h b/es2panda/ir/ts/tsTypeParameterInstantiation.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bedba52ffdf88b65b06ccff21e4b6270c8dddd7
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeParameterInstantiation.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_PARAMETER_INSTANTIATION_H
+#define ES2PANDA_IR_TS_TYPE_PARAMETER_INSTANTIATION_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterInstantiation : public Expression {
+public:
+    explicit TSTypeParameterInstantiation(ArenaVector<Expression *> &&params)
+        : Expression(AstNodeType::TS_TYPE_PARAMETER_INSTANTIATION), params_(std::move(params))
+    {
+    }
+
+    const ArenaVector<Expression *> &Params() const
+    {
+        return params_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ArenaVector<Expression *> params_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypePredicate.cpp b/es2panda/ir/ts/tsTypePredicate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d5cd205ec9a88490fd97b3724d58e0e1a38a376d
--- /dev/null
+++ b/es2panda/ir/ts/tsTypePredicate.cpp
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypePredicate.h"
+
+#include <ir/astDump.h>
+#include <ir/expression.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypePredicate::Iterate(const NodeTraverser &cb) const
+{
+    cb(parameterName_);
+    if (typeAnnotation_) {
+        cb(typeAnnotation_);
+    }
+}
+
+void TSTypePredicate::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTypePredicate"},
+                 {"parameterName", parameterName_},
+                 {"typeAnnotation", AstDumper::Nullable(typeAnnotation_)},
+                 {"asserts", asserts_}});
+}
+
+void TSTypePredicate::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypePredicate::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypePredicate.h b/es2panda/ir/ts/tsTypePredicate.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ebc93222003b7e6d45a6c7827b34e5c3d50daf2
--- /dev/null
+++ b/es2panda/ir/ts/tsTypePredicate.h
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_PREDICATE_H
+#define ES2PANDA_IR_TS_TYPE_PREDICATE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypePredicate : public Expression {
+public:
+    explicit TSTypePredicate(Expression *parameterName, Expression *typeAnnotation, bool asserts)
+        : Expression(AstNodeType::TS_TYPE_PREDICATE),
+          parameterName_(parameterName),
+          typeAnnotation_(typeAnnotation),
+          asserts_(asserts)
+    {
+    }
+
+    Expression *ParameterName() const
+    {
+        return parameterName_;
+    }
+
+    Expression *TypeAnnotation() const
+    {
+        return typeAnnotation_;
+    }
+
+    bool Asserts() const
+    {
+        return asserts_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *parameterName_;
+    Expression *typeAnnotation_;
+    bool asserts_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeQuery.cpp b/es2panda/ir/ts/tsTypeQuery.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..917bfedbb2d027b6670b1a1d87762cd8daf51654
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeQuery.cpp
@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeQuery.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeQuery::Iterate(const NodeTraverser &cb) const
+{
+    cb(exprName_);
+}
+
+void TSTypeQuery::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSTypeQuery"}, {"exprName", exprName_}});
+}
+
+void TSTypeQuery::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeQuery::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    ASSERT(exprName_->IsIdentifier() || exprName_->IsTSQualifiedName());
+    return exprName_->Check(checker);
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeQuery.h b/es2panda/ir/ts/tsTypeQuery.h
new file mode 100644
index 0000000000000000000000000000000000000000..060a2c1bbe7dc66171521fca7ebbe01484a3619b
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeQuery.h
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_QUERY_H
+#define ES2PANDA_IR_TS_TYPE_QUERY_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeQuery : public Expression {
+public:
+    explicit TSTypeQuery(Expression *exprName) : Expression(AstNodeType::TS_TYPE_QUERY), exprName_(exprName) {}
+
+    const Expression *ExprName() const
+    {
+        return exprName_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *exprName_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsTypeReference.cpp b/es2panda/ir/ts/tsTypeReference.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85859524242d492f76b62897d9b5ce529290b812
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeReference.cpp
@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsTypeReference.h"
+
+#include <binder/declaration.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+#include <ir/expressions/identifier.h>
+#include <ir/ts/tsInterfaceDeclaration.h>
+#include <ir/ts/tsTypeAliasDeclaration.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+#include <ir/ts/tsEnumDeclaration.h>
+
+namespace panda::es2panda::ir {
+
+void TSTypeReference::Iterate(const NodeTraverser &cb) const
+{
+    if (typeParams_) {
+        cb(typeParams_);
+    }
+
+    cb(typeName_);
+}
+
+void TSTypeReference::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add(
+        {{"type", "TSTypeReference"}, {"typeName", typeName_}, {"typeParameters", AstDumper::Optional(typeParams_)}});
+}
+
+void TSTypeReference::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSTypeReference::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    if (typeName_->IsIdentifier()) {
+        return ResolveReference(checker, typeName_->AsIdentifier()->Variable(), typeName_->AsIdentifier(), typeParams_);
+    }
+
+    ASSERT(typeName_->IsTSQualifiedName());
+    return typeName_->Check(checker);
+}
+
+checker::Type *TSTypeReference::ResolveReference(checker::Checker *checker, binder::Variable *var,
+                                                 const ir::Identifier *refIdent,
+                                                 const ir::TSTypeParameterInstantiation *typeParams)
+{
+    if (!var) {
+        checker->ThrowTypeError({"Cannot find name ", refIdent->Name()}, refIdent->Start());
+    }
+
+    const binder::Decl *decl = var->Declaration();
+
+    if (decl->IsTypeParameterDecl()) {
+        ASSERT(var->TsType() && var->TsType()->IsTypeParameter());
+        return checker->Allocator()->New<checker::TypeReference>(var->TsType()->AsTypeParameter()->DefaultTypeRef());
+    }
+
+    if (!var->TsType()) {
+        checker::Type *bindingType = nullptr;
+
+        if (var->HasFlag(binder::VariableFlags::TYPE_ALIAS)) {
+            if (!checker->TypeStack().insert(decl->Node()).second) {
+                checker->ThrowTypeError({"Type alias '", refIdent->Name(), "' circularly references itself"},
+                                        decl->Node()->Start());
+            }
+
+            bindingType = decl->Node()->AsTSTypeAliasDeclaration()->InferType(checker, var);
+            checker->TypeStack().erase(decl->Node());
+        } else if (var->HasFlag(binder::VariableFlags::INTERFACE)) {
+            bindingType = decl->Node()->AsTSInterfaceDeclaration()->InferType(checker, var);
+        } else if (var->HasFlag(binder::VariableFlags::ENUM_LITERAL)) {
+            bindingType =
+                decl->Node()->AsTSEnumDeclaration()->InferType(checker, decl->Node()->AsTSEnumDeclaration()->IsConst());
+        } else {
+            // TODO(aszilagyi)
+            bindingType = checker->GlobalAnyType();
+        }
+
+        bindingType->SetVariable(var);
+        var->SetTsType(bindingType);
+    }
+
+    if (var->HasFlag(binder::VariableFlags::INTERFACE)) {
+        for (const auto *it : decl->AsInterfaceDecl()->Decls()) {
+            if (!it->TypeParams()) {
+                continue;
+            }
+
+            return checker->InstantiateGenericInterface(var, decl, typeParams, refIdent->Start());
+        }
+    }
+
+    if (var->HasFlag(binder::VariableFlags::TYPE_ALIAS) && decl->Node()->AsTSTypeAliasDeclaration()->TypeParams()) {
+        return checker->InstantiateGenericTypeAlias(var, decl->Node()->AsTSTypeAliasDeclaration()->TypeParams(),
+                                                    typeParams, refIdent->Start());
+    }
+
+    return var->TsType();
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsTypeReference.h b/es2panda/ir/ts/tsTypeReference.h
new file mode 100644
index 0000000000000000000000000000000000000000..40f024a24c46ea5c1b1337510a30c900ed34f8c9
--- /dev/null
+++ b/es2panda/ir/ts/tsTypeReference.h
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_TYPE_REFERENCE_H
+#define ES2PANDA_IR_TS_TYPE_REFERENCE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::binder {
+class ScopeFindResult;
+class Variable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSTypeParameterInstantiation;
+
+class TSTypeReference : public Expression {
+public:
+    explicit TSTypeReference(Expression *typeName, TSTypeParameterInstantiation *typeParams)
+        : Expression(AstNodeType::TS_TYPE_REFERENCE), typeName_(typeName), typeParams_(typeParams)
+    {
+    }
+
+    const TSTypeParameterInstantiation *TypeParams() const
+    {
+        return typeParams_;
+    }
+
+    const Expression *TypeName() const
+    {
+        return typeName_;
+    }
+
+    static checker::Type *ResolveReference(checker::Checker *checker, binder::Variable *var,
+                                           const ir::Identifier *refIdent,
+                                           const ir::TSTypeParameterInstantiation *typeParams);
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    Expression *typeName_;
+    TSTypeParameterInstantiation *typeParams_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsUndefinedKeyword.cpp b/es2panda/ir/ts/tsUndefinedKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a63679fc3406b03830e3fdd4a385d73a657c37b
--- /dev/null
+++ b/es2panda/ir/ts/tsUndefinedKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsUndefinedKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSUndefinedKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSUndefinedKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSUndefinedKeyword"}});
+}
+
+void TSUndefinedKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSUndefinedKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsUndefinedKeyword.h b/es2panda/ir/ts/tsUndefinedKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..e787ed0f75ea9e24330a17667f8a414fe340a3df
--- /dev/null
+++ b/es2panda/ir/ts/tsUndefinedKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_UNDEFINED_KEYWORD_H
+#define ES2PANDA_IR_TS_UNDEFINED_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSUndefinedKeyword : public Expression {
+public:
+    explicit TSUndefinedKeyword() : Expression(AstNodeType::TS_UNDEFINED_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsUnionType.cpp b/es2panda/ir/ts/tsUnionType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f58f9d7cb65ec46d59233526e4ff81a192704c25
--- /dev/null
+++ b/es2panda/ir/ts/tsUnionType.cpp
@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsUnionType.h"
+
+#include <typescript/checker.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSUnionType::Iterate(const NodeTraverser &cb) const
+{
+    for (auto *it : types_) {
+        cb(it);
+    }
+}
+
+void TSUnionType::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSUnionType"}, {"types", types_}});
+}
+
+void TSUnionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSUnionType::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    std::vector<checker::Type *> types;
+
+    for (auto *it : types_) {
+        types.push_back(it->Check(checker));
+    }
+
+    return checker->CreateUnionType(std::move(types));
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsUnionType.h b/es2panda/ir/ts/tsUnionType.h
new file mode 100644
index 0000000000000000000000000000000000000000..e55471e32ac45f08ef0c8977176f742598dd9d53
--- /dev/null
+++ b/es2panda/ir/ts/tsUnionType.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_UNION_TYPE_H
+#define ES2PANDA_IR_TS_UNION_TYPE_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSUnionType : public Expression {
+public:
+    explicit TSUnionType(ArenaVector<Expression *> &&types)
+        : Expression(AstNodeType::TS_UNION_TYPE), types_(std::move(types))
+    {
+    }
+
+    const ArenaVector<Expression *> &Types() const
+    {
+        return types_;
+    }
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+
+private:
+    ArenaVector<Expression *> types_;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsUnknownKeyword.cpp b/es2panda/ir/ts/tsUnknownKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..851555b8cdcdfa34267a25494dcdf730ecb365c7
--- /dev/null
+++ b/es2panda/ir/ts/tsUnknownKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsUnknownKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSUnknownKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSUnknownKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSUnknownKeyword"}});
+}
+
+void TSUnknownKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSUnknownKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsUnknownKeyword.h b/es2panda/ir/ts/tsUnknownKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec850cffaf4c6748872408f996bb984d06c93b70
--- /dev/null
+++ b/es2panda/ir/ts/tsUnknownKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_UNKNOWN_KEYWORD_H
+#define ES2PANDA_IR_TS_UNKNOWN_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSUnknownKeyword : public Expression {
+public:
+    explicit TSUnknownKeyword() : Expression(AstNodeType::TS_UNKNOWN_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/ts/tsVoidKeyword.cpp b/es2panda/ir/ts/tsVoidKeyword.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c26881bce74c680d2f21f1577c88ac4c1c9c1147
--- /dev/null
+++ b/es2panda/ir/ts/tsVoidKeyword.cpp
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tsVoidKeyword.h"
+
+#include <ir/astDump.h>
+
+namespace panda::es2panda::ir {
+
+void TSVoidKeyword::Iterate([[maybe_unused]] const NodeTraverser &cb) const {}
+
+void TSVoidKeyword::Dump(ir::AstDumper *dumper) const
+{
+    dumper->Add({{"type", "TSVoidKeyword"}});
+}
+
+void TSVoidKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+
+checker::Type *TSVoidKeyword::Check([[maybe_unused]] checker::Checker *checker) const
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::ir
diff --git a/es2panda/ir/ts/tsVoidKeyword.h b/es2panda/ir/ts/tsVoidKeyword.h
new file mode 100644
index 0000000000000000000000000000000000000000..9212937860f8c08c93664bd2588ac8b9363b96b6
--- /dev/null
+++ b/es2panda/ir/ts/tsVoidKeyword.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_TS_VOID_KEYWORD_H
+#define ES2PANDA_IR_TS_VOID_KEYWORD_H
+
+#include <ir/expression.h>
+
+namespace panda::es2panda::compiler {
+class PandaGen;
+}  // namespace panda::es2panda::compiler
+
+namespace panda::es2panda::checker {
+class Checker;
+class Type;
+}  // namespace panda::es2panda::checker
+
+namespace panda::es2panda::ir {
+
+class TSVoidKeyword : public Expression {
+public:
+    explicit TSVoidKeyword() : Expression(AstNodeType::TS_VOID_KEYWORD) {}
+
+    void Iterate(const NodeTraverser &cb) const override;
+    void Dump(ir::AstDumper *dumper) const override;
+    void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/ir/validationInfo.h b/es2panda/ir/validationInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..26b0446739500dbf7fb142ed38d369bec069d7be
--- /dev/null
+++ b/es2panda/ir/validationInfo.h
@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_IR_VALIDATION_INFO_H
+#define ES2PANDA_IR_VALIDATION_INFO_H
+
+#include <lexer/token/sourceLocation.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::ir {
+class ValidationInfo {
+public:
+    ValidationInfo() noexcept = default;
+    ValidationInfo(util::StringView m, lexer::SourcePosition p) noexcept : msg(m), pos(p) {}
+
+    inline bool Fail() const
+    {
+        return !msg.Empty();
+    }
+
+    util::StringView msg {};
+    lexer::SourcePosition pos {};
+};
+}  // namespace panda::es2panda::ir
+
+#endif
diff --git a/es2panda/lexer/keywordString.h b/es2panda/lexer/keywordString.h
new file mode 100644
index 0000000000000000000000000000000000000000..fcc8c13590fb01a808cb0c2c0a78f003c169dfef
--- /dev/null
+++ b/es2panda/lexer/keywordString.h
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_KEYWORD_STRING_H
+#define ES2PANDA_PARSER_CORE_KEYWORD_STRING_H
+
+#include <lexer/token/tokenType.h>
+#include <macros.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::lexer {
+
+struct KeywordString {
+    constexpr KeywordString(std::string_view s, TokenType t, TokenType k) : str(s), tokenType(t), keywordType(k) {}
+
+    explicit KeywordString(std::string_view &s) : str(s) {}
+
+    std::string_view str;
+    TokenType tokenType {};
+    TokenType keywordType {};
+};
+
+}  // namespace panda::es2panda::lexer
+
+#endif
diff --git a/es2panda/lexer/keywordsUtil.cpp b/es2panda/lexer/keywordsUtil.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..452a122f82fbad5947d1bb8963524b6922849ff5
--- /dev/null
+++ b/es2panda/lexer/keywordsUtil.cpp
@@ -0,0 +1,304 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "keywordsUtil.h"
+
+#include <gen/keywords.h>
+#include <lexer/lexer.h>
+#include <unicode/uchar.h>
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::lexer {
+
+enum class AsciiFlags : uint8_t {
+    NONE = 0,
+    ID_START = 1 << 0,
+    ID_CONTINUE = 1 << 1,
+};
+
+constexpr AsciiFlags operator|(AsciiFlags a, AsciiFlags b)
+{
+    using utype = std::underlying_type_t<AsciiFlags>;
+    return static_cast<AsciiFlags>(static_cast<utype>(a) | static_cast<utype>(b));
+}
+
+inline std::underlying_type_t<AsciiFlags> operator&(AsciiFlags a, AsciiFlags b)
+{
+    using utype = std::underlying_type_t<AsciiFlags>;
+    /* NOLINTNEXTLINE(hicpp-signed-bitwise) */
+    return static_cast<utype>(static_cast<utype>(a) & static_cast<utype>(b));
+}
+
+constexpr std::array<AsciiFlags, 128> ASCII_FLAGS = {{
+    AsciiFlags::NONE,                               /* NUL */
+    AsciiFlags::NONE,                               /* SOH */
+    AsciiFlags::NONE,                               /* STX */
+    AsciiFlags::NONE,                               /* ETX */
+    AsciiFlags::NONE,                               /* EOT */
+    AsciiFlags::NONE,                               /* ENQ */
+    AsciiFlags::NONE,                               /* ACK */
+    AsciiFlags::NONE,                               /* BEL */
+    AsciiFlags::NONE,                               /* BS */
+    AsciiFlags::NONE,                               /* TAB */
+    AsciiFlags::NONE,                               /* LF */
+    AsciiFlags::NONE,                               /* VT */
+    AsciiFlags::NONE,                               /* FF */
+    AsciiFlags::NONE,                               /* CR */
+    AsciiFlags::NONE,                               /* SO */
+    AsciiFlags::NONE,                               /* SI */
+    AsciiFlags::NONE,                               /* DLE */
+    AsciiFlags::NONE,                               /* DC1 */
+    AsciiFlags::NONE,                               /* DC2 */
+    AsciiFlags::NONE,                               /* DC3 */
+    AsciiFlags::NONE,                               /* DC4 */
+    AsciiFlags::NONE,                               /* NAK */
+    AsciiFlags::NONE,                               /* SYN */
+    AsciiFlags::NONE,                               /* ETB */
+    AsciiFlags::NONE,                               /* CAN */
+    AsciiFlags::NONE,                               /* EM */
+    AsciiFlags::NONE,                               /* SUB */
+    AsciiFlags::NONE,                               /* ESC */
+    AsciiFlags::NONE,                               /* FS */
+    AsciiFlags::NONE,                               /* GS */
+    AsciiFlags::NONE,                               /* RS */
+    AsciiFlags::NONE,                               /* US */
+    AsciiFlags::NONE,                               /* Space */
+    AsciiFlags::NONE,                               /* ! */
+    AsciiFlags::NONE,                               /* " */
+    AsciiFlags::NONE,                               /* # */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* $ */
+    AsciiFlags::NONE,                               /* % */
+    AsciiFlags::NONE,                               /* & */
+    AsciiFlags::NONE,                               /* ' */
+    AsciiFlags::NONE,                               /* ( */
+    AsciiFlags::NONE,                               /* ) */
+    AsciiFlags::NONE,                               /* * */
+    AsciiFlags::NONE,                               /* + */
+    AsciiFlags::NONE,                               /* , */
+    AsciiFlags::NONE,                               /* - */
+    AsciiFlags::NONE,                               /* . */
+    AsciiFlags::NONE,                               /* / */
+    AsciiFlags::ID_CONTINUE,                        /* 0 */
+    AsciiFlags::ID_CONTINUE,                        /* 1 */
+    AsciiFlags::ID_CONTINUE,                        /* 2 */
+    AsciiFlags::ID_CONTINUE,                        /* 3 */
+    AsciiFlags::ID_CONTINUE,                        /* 4 */
+    AsciiFlags::ID_CONTINUE,                        /* 5 */
+    AsciiFlags::ID_CONTINUE,                        /* 6 */
+    AsciiFlags::ID_CONTINUE,                        /* 7 */
+    AsciiFlags::ID_CONTINUE,                        /* 8 */
+    AsciiFlags::ID_CONTINUE,                        /* 9 */
+    AsciiFlags::NONE,                               /* : */
+    AsciiFlags::NONE,                               /* ; */
+    AsciiFlags::NONE,                               /* < */
+    AsciiFlags::NONE,                               /* = */
+    AsciiFlags::NONE,                               /* > */
+    AsciiFlags::NONE,                               /* ? */
+    AsciiFlags::NONE,                               /* @ */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* A */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* B */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* C */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* D */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* E */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* F */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* G */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* H */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* I */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* J */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* K */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* L */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* M */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* N */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* O */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* P */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* Q */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* R */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* S */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* T */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* U */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* V */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* W */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* X */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* Y */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* Z */
+    AsciiFlags::NONE,                               /* [ */
+    AsciiFlags::NONE,                               /* \ */
+    AsciiFlags::NONE,                               /* ] */
+    AsciiFlags::NONE,                               /* ^ */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* _ */
+    AsciiFlags::NONE,                               /* ` */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* a */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* b */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* c */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* d */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* e */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* f */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* g */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* h */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* i */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* j */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* k */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* l */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* m */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* n */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* o */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* p */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* q */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* r */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* s */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* t */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* u */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* v */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* w */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* x */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* y */
+    AsciiFlags::ID_START | AsciiFlags::ID_CONTINUE, /* z */
+    AsciiFlags::NONE,                               /* { */
+    AsciiFlags::NONE,                               /* | */
+    AsciiFlags::NONE,                               /* } */
+    AsciiFlags::NONE,                               /* ~ */
+    AsciiFlags::NONE                                /* DEL */
+}};
+
+bool KeywordsUtil::IsIdentifierStart(char32_t cp)
+{
+    if (cp < LEX_ASCII_MAX_BITS) {
+        return (ASCII_FLAGS[cp] & AsciiFlags::ID_START) != 0;
+    }
+
+    auto uchar = static_cast<UChar>(cp);
+    return u_hasBinaryProperty(uchar, UCHAR_ID_START);
+}
+
+bool KeywordsUtil::IsIdentifierPart(char32_t cp)
+{
+    if (cp < LEX_ASCII_MAX_BITS) {
+        return (ASCII_FLAGS[cp] & AsciiFlags::ID_CONTINUE) != 0;
+    }
+
+    // u_isIDPart or Other_ID_Continue characters or ZWJ/ZWNJ.
+    auto uchar = static_cast<UChar>(cp);
+    return (u_hasBinaryProperty(uchar, UCHAR_ID_CONTINUE) || cp == LEX_CHAR_ZWNJ || cp == LEX_CHAR_ZWJ);
+}
+
+void KeywordsUtil::ScanIdentifierStart(char32_t cp)
+{
+    if (!KeywordsUtil::IsIdentifierStart(cp)) {
+        lexer_->ThrowError("Expected an identifier");
+    }
+
+    cp_ = cp;
+    const auto map = KeywordsMap::Map(cp);
+    ScanIdContinueMaybeKeyword(map);
+}
+
+void KeywordsUtil::ScanIdContinue()
+{
+    util::UString ident(lexer_->Allocator());
+    size_t startPos = lexer_->GetToken().Start().index;
+
+    if (HasEscape()) {
+        ident.Append(cp_);
+        startPos = Iterator().Index();
+    }
+
+    auto escapeEnd = startPos;
+
+    do {
+        if (Iterator().Peek() == LEX_CHAR_BACKSLASH) {
+            ident.Append(lexer_->SourceView(escapeEnd, Iterator().Index()));
+
+            auto cp = ScanUnicodeEscapeSequence();
+            if (!IsIdentifierPart(cp)) {
+                lexer_->ThrowError("Invalid identifier part");
+            }
+
+            escapeEnd = Iterator().Index();
+            ident.Append(cp);
+            continue;
+        }
+
+        size_t cpSize {};
+        auto cp = Iterator().PeekCp(&cpSize);
+        if (!IsIdentifierPart(cp)) {
+            break;
+        }
+
+        Iterator().Forward(cpSize);
+    } while (true);
+
+    lexer_->GetToken().type_ = TokenType::LITERAL_IDENT;
+    lexer_->GetToken().keywordType_ = TokenType::EOS;
+
+    if (HasEscape()) {
+        ident.Append(lexer_->SourceView(escapeEnd, Iterator().Index()));
+        lexer_->GetToken().src_ = ident.View();
+    } else {
+        lexer_->GetToken().src_ = lexer_->SourceView(startPos, Iterator().Index());
+    }
+}
+
+void KeywordsUtil::ScanIdContinueMaybeKeyword(Span<const KeywordString> map)
+{
+    ScanIdContinue();
+
+    if (!HasEscape() || map.empty()) {
+        return;
+    }
+
+    const auto &str = lexer_->GetToken().Ident().Utf8();
+
+    int start = 0;
+    int end = map.size();
+    int middle = end / 2;
+
+    while (true) {
+        const auto &kws = map[middle];
+
+        int relation = str.compare(kws.str);
+        if (relation == 0) {
+            Keywords::SetKeyword(this, kws);
+        }
+
+        if (relation > 0) {
+            start = middle + 1;
+        } else {
+            end = middle;
+        }
+
+        middle = (start + end) / 2;
+
+        if (start >= end) {
+            return;
+        }
+    }
+}
+
+char32_t KeywordsUtil::ScanUnicodeEscapeSequence()
+{
+    ASSERT(Iterator().Peek() == LEX_CHAR_BACKSLASH);
+
+    lexer_->GetToken().flags_ |= lexer::TokenFlags::HAS_ESCAPE;
+
+    Iterator().Forward(1);
+
+    if (Iterator().Peek() != LEX_CHAR_LOWERCASE_U) {
+        return util::StringView::Iterator::INVALID_CP;
+    }
+
+    return lexer_->ScanUnicodeEscapeSequence();
+}
+
+}  // namespace panda::es2panda::lexer
diff --git a/es2panda/lexer/keywordsUtil.h b/es2panda/lexer/keywordsUtil.h
new file mode 100644
index 0000000000000000000000000000000000000000..245a6ddbc3b50890ccf3a42637d3640851899685
--- /dev/null
+++ b/es2panda/lexer/keywordsUtil.h
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_KEYWORDS_UTIL_H
+#define ES2PANDA_PARSER_CORE_KEYWORDS_UTIL_H
+
+#include <lexer/keywordString.h>
+#include <lexer/lexer.h>
+#include <lexer/token/letters.h>
+#include <lexer/token/tokenType.h>
+#include <macros.h>
+#include <util/ustring.h>
+#include <utils/span.h>
+
+namespace panda::es2panda::lexer {
+
+class Lexer;
+
+class KeywordsUtil {
+public:
+    explicit KeywordsUtil(Lexer *lexer, lexer::LexerNextTokenFlags flags) : lexer_(lexer), flags_(flags) {}
+    explicit KeywordsUtil(Lexer *lexer, lexer::LexerNextTokenFlags flags, char32_t cp)
+        : lexer_(lexer), flags_(flags), cp_(cp)
+    {
+    }
+    NO_COPY_SEMANTIC(KeywordsUtil);
+    DEFAULT_MOVE_SEMANTIC(KeywordsUtil);
+    ~KeywordsUtil() = default;
+
+    inline bool HasEscape() const
+    {
+        return (lexer_->GetToken().flags_ & lexer::TokenFlags::HAS_ESCAPE) != 0;
+    }
+
+    template <TokenType keyword_type>
+    inline void SetKeyword(std::string_view str, TokenType type);
+
+    inline util::StringView::Iterator &Iterator()
+    {
+        return lexer_->Iterator();
+    }
+
+    void ScanIdentifierStart(char32_t cp);
+    void ScanIdContinue();
+
+    void ScanIdContinueMaybeKeyword(Span<const KeywordString> map);
+    char32_t ScanUnicodeEscapeSequence();
+
+    static bool IsIdentifierStart(char32_t cp);
+    static bool IsIdentifierPart(char32_t cp);
+
+private:
+    Lexer *lexer_;
+    lexer::LexerNextTokenFlags flags_ {};
+    char32_t cp_ {util::StringView::Iterator::INVALID_CP};
+};
+
+template <TokenType keyword_type>
+inline void KeywordsUtil::SetKeyword(std::string_view str, TokenType type)
+{
+    lexer_->GetToken().src_ = util::StringView(str);
+    // NOLINTNEXTLINE
+    lexer_->GetToken().keywordType_ = keyword_type;
+
+    if (flags_ & lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT) {
+        lexer_->GetToken().type_ = TokenType::LITERAL_IDENT;
+    } else {
+        // NOLINTNEXTLINE
+        lexer_->CheckKeyword<keyword_type>(type, flags_);
+    }
+}
+
+}  // namespace panda::es2panda::lexer
+
+#endif
diff --git a/es2panda/lexer/lexer.cpp b/es2panda/lexer/lexer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..880527188e5aa9296a1ee95482f6557810e2b1d1
--- /dev/null
+++ b/es2panda/lexer/lexer.cpp
@@ -0,0 +1,1602 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "lexer.h"
+
+#include <es2panda.h>
+#include <gen/keywords.h>
+#include <lexer/token/letters.h>
+#include <lexer/token/tokenType.h>
+#include <parser/context/parserContext.h>
+
+#include <array>
+
+namespace panda::es2panda::lexer {
+
+LexerPosition::LexerPosition(const util::StringView &source) : iterator(source) {}
+
+Lexer::Lexer(const parser::ParserContext *parserContext)
+    : allocator_(parserContext->GetProgram()->Allocator()),
+      parserContext_(parserContext),
+      source_(parserContext->GetProgram()->SourceCode()),
+      pos_(source_)
+{
+    SkipWhiteSpaces();
+}
+
+char32_t Lexer::ScanUnicodeEscapeSequence()
+{
+    ASSERT(Iterator().Peek() == LEX_CHAR_LOWERCASE_U);
+
+    Iterator().Forward(1);
+
+    if (Iterator().Peek() == LEX_CHAR_LEFT_BRACE) {
+        Iterator().Forward(1);
+        return ScanUnicodeCodePointEscape();
+    }
+
+    return ScanHexEscape<4>();
+}
+
+char32_t Lexer::ScanUnicodeCodePointEscape()
+{
+    double code = 0;
+    char32_t cp {};
+
+    while (true) {
+        cp = Iterator().Peek();
+        if (!IsHexDigit(cp)) {
+            break;
+        }
+
+        Iterator().Forward(1);
+
+        constexpr auto multiplier = 16;
+        code = code * multiplier + HexValue(cp);
+        if (code > UNICODE_CODE_POINT_MAX) {
+            ThrowError("Invalid unicode escape sequence");
+        }
+    }
+
+    if (cp != LEX_CHAR_RIGHT_BRACE) {
+        ThrowError("Invalid unicode escape sequence");
+    }
+
+    Iterator().Forward(1);
+    return static_cast<char32_t>(code);
+}
+
+ArenaAllocator *Lexer::Allocator()
+{
+    return allocator_;
+}
+
+Token &Lexer::GetToken()
+{
+    return pos_.token;
+}
+
+const Token &Lexer::GetToken() const
+{
+    return pos_.token;
+}
+
+size_t Lexer::Line() const
+{
+    return pos_.line;
+}
+
+LexerPosition Lexer::Save() const
+{
+    return pos_;
+}
+
+void Lexer::BackwardToken(TokenType type, size_t offset)
+{
+    pos_.token.type_ = type;
+    pos_.iterator.Reset(GetToken().End().index - offset);
+    pos_.nextTokenLine = 0;
+}
+
+void Lexer::ForwardToken(TokenType type, size_t offset)
+{
+    pos_.token.type_ = type;
+    pos_.iterator.Forward(offset);
+    SkipWhiteSpaces();
+}
+
+void Lexer::Rewind(const LexerPosition &pos)
+{
+    pos_ = pos;
+}
+
+char32_t Lexer::Lookahead()
+{
+    return Iterator().Peek();
+}
+
+util::StringView Lexer::SourceView(const util::StringView::Iterator &begin, const util::StringView::Iterator &end) const
+{
+    return SourceView(begin.Index(), end.Index());
+}
+
+util::StringView Lexer::SourceView(size_t begin, size_t end) const
+{
+    return source_.Substr(begin, end);
+}
+
+void Lexer::SkipMultiLineComment()
+{
+    while (true) {
+        switch (Iterator().Next()) {
+            case util::StringView::Iterator::INVALID_CP: {
+                ThrowError("Unterminated multi-line comment");
+                break;
+            }
+            case LEX_CHAR_LF:
+            case LEX_CHAR_CR:
+            case LEX_CHAR_LS:
+            case LEX_CHAR_PS: {
+                pos_.nextTokenLine++;
+                continue;
+            }
+            case LEX_CHAR_ASTERISK: {
+                if (Iterator().Peek() == LEX_CHAR_SLASH) {
+                    Iterator().Forward(1);
+                    return;
+                }
+
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+    }
+}
+
+/* New line character is not processed */
+void Lexer::SkipSingleLineComment()
+{
+    while (true) {
+        switch (Iterator().Next()) {
+            case util::StringView::Iterator::INVALID_CP:
+            case LEX_CHAR_CR: {
+                if (Iterator().Peek() == LEX_CHAR_LF) {
+                    Iterator().Forward(1);
+                }
+
+                [[fallthrough]];
+            }
+            case LEX_CHAR_LF:
+            case LEX_CHAR_LS:
+            case LEX_CHAR_PS: {
+                pos_.nextTokenLine++;
+                return;
+            }
+            default: {
+                break;
+            }
+        }
+    }
+}
+
+void Lexer::ThrowError(std::string_view message)
+{
+    throw es2panda::Error(es2panda::ErrorType::SYNTAX, message, pos_.line, Iterator().Index());
+}
+
+void Lexer::CheckNumberLiteralEnd()
+{
+    if (Iterator().Peek() == LEX_CHAR_LOWERCASE_N) {
+        Iterator().Forward(1);
+        GetToken().flags_ |= TokenFlags::NUMBER_BIGINT;
+    }
+
+    GetToken().src_ = SourceView(GetToken().Start().index, Iterator().Index());
+    const auto nextCp = Iterator().PeekCp();
+    if (KeywordsUtil::IsIdentifierStart(nextCp) || IsDecimalDigit(nextCp)) {
+        ThrowError("Invalid numeric literal");
+    }
+}
+
+void Lexer::ScanNumberLeadingZero()
+{
+    GetToken().type_ = TokenType::LITERAL_NUMBER;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_LOWERCASE_X:
+        case LEX_CHAR_UPPERCASE_X: {
+            Iterator().Forward(1);
+            constexpr auto RADIX = 16;
+            ScanNumberRadix<IsHexDigit, RADIX>();
+            CheckNumberLiteralEnd();
+            return;
+        }
+        case LEX_CHAR_LOWERCASE_B:
+        case LEX_CHAR_UPPERCASE_B: {
+            Iterator().Forward(1);
+            constexpr auto RADIX = 2;
+            ScanNumberRadix<IsBinaryDigit, RADIX>();
+            CheckNumberLiteralEnd();
+            return;
+        }
+        case LEX_CHAR_LOWERCASE_O:
+        case LEX_CHAR_UPPERCASE_O: {
+            Iterator().Forward(1);
+            constexpr auto RADIX = 8;
+            ScanNumberRadix<IsOctalDigit, RADIX>();
+
+            switch (Iterator().Peek()) {
+                case LEX_CHAR_8:
+                case LEX_CHAR_9: {
+                    ThrowError("Invalid octal digit");
+                }
+                default: {
+                    break;
+                }
+            }
+
+            CheckNumberLiteralEnd();
+            return;
+        }
+        case LEX_CHAR_0:
+        case LEX_CHAR_1:
+        case LEX_CHAR_2:
+        case LEX_CHAR_3:
+        case LEX_CHAR_4:
+        case LEX_CHAR_5:
+        case LEX_CHAR_6:
+        case LEX_CHAR_7: {
+            ThrowError("Implicit octal literal not allowed");
+            break;
+        }
+        case LEX_CHAR_8:
+        case LEX_CHAR_9: {
+            ThrowError("NonOctalDecimalIntegerLiteral is not enabled in strict mode code");
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    ScanNumber(Iterator().Peek() == LEX_CHAR_0);
+}
+
+void Lexer::ScanDecimalNumbers(bool allowNumericSeparator)
+{
+    bool allowNumericOnNext = true;
+
+    while (true) {
+        switch (Iterator().Peek()) {
+            case LEX_CHAR_0:
+            case LEX_CHAR_1:
+            case LEX_CHAR_2:
+            case LEX_CHAR_3:
+            case LEX_CHAR_4:
+            case LEX_CHAR_5:
+            case LEX_CHAR_6:
+            case LEX_CHAR_7:
+            case LEX_CHAR_8:
+            case LEX_CHAR_9: {
+                Iterator().Forward(1);
+                allowNumericOnNext = true;
+                break;
+            }
+            case LEX_CHAR_UNDERSCORE: {
+                Iterator().Backward(1);
+
+                if (Iterator().Peek() == LEX_CHAR_DOT || !allowNumericSeparator || !allowNumericOnNext) {
+                    Iterator().Forward(1);
+                    ThrowError("Invalid numeric separator");
+                }
+
+                GetToken().flags_ |= TokenFlags::NUMBER_HAS_UNDERSCORE;
+                Iterator().Forward(2);
+                allowNumericOnNext = false;
+                break;
+            }
+            default: {
+                if (!allowNumericOnNext) {
+                    ThrowError("Numeric separators are not allowed at the end of numeric literals");
+                }
+                return;
+            }
+        }
+    }
+}
+
+void Lexer::ConvertNumber(size_t exponentSignPos)
+{
+    util::StringView sv = SourceView(GetToken().Start().index, Iterator().Index());
+    std::string utf8 = std::string {sv.Utf8()};
+    bool needConversion = false;
+
+    if (exponentSignPos != std::numeric_limits<size_t>::max()) {
+        utf8.insert(exponentSignPos, 1, '+');
+        needConversion = true;
+    }
+
+    if (GetToken().flags_ & TokenFlags::NUMBER_HAS_UNDERSCORE) {
+        utf8.erase(std::remove(utf8.begin(), utf8.end(), LEX_CHAR_UNDERSCORE), utf8.end());
+        needConversion = true;
+    }
+
+    if (needConversion) {
+        util::UString converted(utf8, Allocator());
+        GetToken().src_ = converted.View();
+    } else {
+        GetToken().src_ = sv;
+    }
+
+    try {
+        GetToken().number_ = static_cast<double>(std::stold(utf8, nullptr));
+    } catch (const std::invalid_argument &) {
+        ThrowError("Invalid number");
+    } catch (const std::out_of_range &) {
+        // TODO(frobert): look for a more elegant solution to this
+        GetToken().number_ = std::numeric_limits<double>::infinity();
+    }
+}
+void Lexer::ScanNumber(bool allowNumericSeparator, bool allowBigInt)
+{
+    GetToken().type_ = TokenType::LITERAL_NUMBER;
+
+    ScanDecimalNumbers(allowNumericSeparator);
+
+    size_t exponentSignPos = std::numeric_limits<size_t>::max();
+    bool parseExponent = true;
+
+    if (Iterator().Peek() == LEX_CHAR_DOT) {
+        allowBigInt = false;
+        Iterator().Forward(1);
+
+        auto cp = Iterator().Peek();
+        if (IsDecimalDigit(cp) || cp == LEX_CHAR_LOWERCASE_E || LEX_CHAR_UPPERCASE_E) {
+            ScanDecimalNumbers(allowNumericSeparator);
+        } else {
+            parseExponent = false;
+        }
+    }
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_LOWERCASE_E:
+        case LEX_CHAR_UPPERCASE_E: {
+            allowBigInt = false;
+
+            if (!parseExponent) {
+                break;
+            }
+
+            Iterator().Forward(1);
+
+            switch (Iterator().Peek()) {
+                case LEX_CHAR_UNDERSCORE: {
+                    break;
+                }
+                case LEX_CHAR_PLUS:
+                case LEX_CHAR_MINUS: {
+                    Iterator().Forward(1);
+                    break;
+                }
+                default: {
+                    exponentSignPos = Iterator().Index() - GetToken().Start().index;
+                    break;
+                }
+            }
+
+            if (!IsDecimalDigit(Iterator().Peek())) {
+                ThrowError("Invalid numeric literal");
+            }
+            ScanDecimalNumbers(allowNumericSeparator);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    CheckNumberLiteralEnd();
+
+    if (GetToken().flags_ & TokenFlags::NUMBER_BIGINT) {
+        if (!allowBigInt) {
+            ThrowError("Invalid BigInt number");
+        }
+
+        return;
+    }
+
+    ConvertNumber(exponentSignPos);
+}
+
+void Lexer::PushTemplateContext(TemplateLiteralParserContext *ctx)
+{
+    tlCtx_ = ctx;
+}
+
+void Lexer::ScanTemplateStringEnd()
+{
+    ASSERT(Iterator().Peek() == LEX_CHAR_BACK_TICK);
+    Iterator().Forward(1);
+    SetTokenEnd();
+    SkipWhiteSpaces();
+}
+
+LexerTemplateString Lexer::ScanTemplateString()
+{
+    LexerTemplateString templateStr(Allocator());
+    size_t cpSize = 0;
+
+    while (true) {
+        char32_t cp = Iterator().PeekCp(&cpSize);
+
+        switch (cp) {
+            case util::StringView::Iterator::INVALID_CP: {
+                ThrowError("Unexpected token, expected '${' or '`'");
+                break;
+            }
+            case LEX_CHAR_BACK_TICK: {
+                templateStr.end = Iterator().Index();
+                return templateStr;
+            }
+            case LEX_CHAR_CR: {
+                Iterator().Forward(1);
+
+                if (Iterator().Peek() != LEX_CHAR_LF) {
+                    Iterator().Backward(1);
+                }
+
+                [[fallthrough]];
+            }
+            case LEX_CHAR_LF: {
+                pos_.line++;
+                templateStr.str.Append(LEX_CHAR_LF);
+                Iterator().Forward(1);
+                continue;
+            }
+            case LEX_CHAR_BACKSLASH: {
+                Iterator().Forward(1);
+
+                char32_t nextCp = Iterator().Peek();
+                if (IsOctalDigit(nextCp)) {
+                    Iterator().Forward(1);
+
+                    if (Iterator().Peek() != LEX_CHAR_BACK_TICK) {
+                        ThrowError("Octal escape sequences are not allowed in template strings");
+                    }
+
+                    Iterator().Backward(1);
+                }
+
+                if (nextCp == LEX_CHAR_BACK_TICK || nextCp == LEX_CHAR_BACKSLASH) {
+                    templateStr.str.Append(cp);
+                    templateStr.str.Append(nextCp);
+                    Iterator().Forward(1);
+                    continue;
+                }
+
+                Iterator().Backward(1);
+                break;
+            }
+            case LEX_CHAR_DOLLAR_SIGN: {
+                templateStr.end = Iterator().Index();
+                Iterator().Forward(1);
+
+                if (Iterator().Peek() == LEX_CHAR_LEFT_BRACE) {
+                    Iterator().Forward(1);
+                    templateStr.scanExpression = true;
+                    SkipWhiteSpaces();
+                    return templateStr;
+                }
+
+                templateStr.str.Append(cp);
+                continue;
+            }
+            default: {
+                break;
+            }
+        }
+
+        templateStr.str.Append(cp);
+        Iterator().Forward(cpSize);
+    }
+
+    UNREACHABLE();
+    return templateStr;
+}
+
+void Lexer::ResetTokenEnd()
+{
+    SetTokenStart();
+    pos_.iterator.Reset(GetToken().End().index);
+    pos_.line = GetToken().End().line;
+    pos_.nextTokenLine = 0;
+}
+
+void Lexer::ScanStringUnicodePart(util::UString *str)
+{
+    size_t cpSize {};
+    char32_t cp = Iterator().PeekCp(&cpSize);
+
+    switch (cp) {
+        case util::StringView::Iterator::INVALID_CP: {
+            ThrowError("Unterminated string");
+            break;
+        }
+        case LEX_CHAR_CR: {
+            Iterator().Forward(1);
+            if (Iterator().Peek() != LEX_CHAR_LF) {
+                Iterator().Backward(1);
+            }
+
+            [[fallthrough]];
+        }
+        case LEX_CHAR_LS:
+        case LEX_CHAR_PS:
+        case LEX_CHAR_LF: {
+            pos_.line++;
+            Iterator().Forward(cpSize);
+            return;
+        }
+        case LEX_CHAR_LOWERCASE_B: {
+            cp = LEX_CHAR_BS;
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_T: {
+            cp = LEX_CHAR_TAB;
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_N: {
+            cp = LEX_CHAR_LF;
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_V: {
+            cp = LEX_CHAR_VT;
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_F: {
+            cp = LEX_CHAR_FF;
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_R: {
+            cp = LEX_CHAR_CR;
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_X: {
+            Iterator().Forward(1);
+            str->Append(ScanHexEscape<2>());
+            return;
+        }
+        case LEX_CHAR_LOWERCASE_U: {
+            cp = ScanUnicodeEscapeSequence();
+            str->Append(cp);
+            return;
+        }
+        case LEX_CHAR_0: {
+            Iterator().Forward(1);
+            bool isDecimal = IsDecimalDigit(Iterator().Peek());
+            Iterator().Backward(1);
+
+            if (!isDecimal) {
+                cp = LEX_CHAR_NULL;
+                break;
+            }
+
+            [[fallthrough]];
+        }
+        default: {
+            if (IsDecimalDigit(Iterator().Peek())) {
+                ThrowError("Invalid character escape sequence in strict mode");
+            }
+
+            break;
+        }
+    }
+
+    Iterator().Forward(cpSize);
+    str->Append(cp);
+}
+
+void Lexer::ScanQuestionPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_QUESTION_MARK;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_QUESTION: {
+            GetToken().type_ = TokenType::PUNCTUATOR_NULLISH_COALESCING;
+            Iterator().Forward(1);
+
+            switch (Iterator().Peek()) {
+                case LEX_CHAR_EQUALS: {
+                    GetToken().type_ = TokenType::PUNCTUATOR_LOGICAL_NULLISH_EQUAL;
+                    Iterator().Forward(1);
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+
+            break;
+        }
+        case LEX_CHAR_DOT: {
+            Iterator().Forward(1);
+
+            if (!IsDecimalDigit(Iterator().Peek())) {
+                GetToken().type_ = TokenType::PUNCTUATOR_QUESTION_DOT;
+                return;
+            }
+
+            Iterator().Backward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanLessThanPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_LESS_THAN;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_LESS_THAN: {
+            GetToken().type_ = TokenType::PUNCTUATOR_LEFT_SHIFT;
+            Iterator().Forward(1);
+
+            if (Iterator().Peek() == LEX_CHAR_EQUALS) {
+                GetToken().type_ = TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL;
+                Iterator().Forward(1);
+            }
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_LESS_THAN_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanGreaterThanPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_GREATER_THAN;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_GREATER_THAN: {
+            GetToken().type_ = TokenType::PUNCTUATOR_RIGHT_SHIFT;
+            Iterator().Forward(1);
+
+            switch (Iterator().Peek()) {
+                case LEX_CHAR_GREATER_THAN: {
+                    GetToken().type_ = TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT;
+                    Iterator().Forward(1);
+
+                    if (Iterator().Peek() == LEX_CHAR_EQUALS) {
+                        GetToken().type_ = TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL;
+                        Iterator().Forward(1);
+                    }
+                    break;
+                }
+                case LEX_CHAR_EQUALS: {
+                    GetToken().type_ = TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL;
+                    Iterator().Forward(1);
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_GREATER_THAN_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanEqualsPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_SUBSTITUTION;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_EQUAL;
+            Iterator().Forward(1);
+
+            if (Iterator().Peek() == LEX_CHAR_EQUALS) {
+                GetToken().type_ = TokenType::PUNCTUATOR_STRICT_EQUAL;
+                Iterator().Forward(1);
+            }
+            break;
+        }
+        case LEX_CHAR_GREATER_THAN: {
+            GetToken().type_ = TokenType::PUNCTUATOR_ARROW;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanExclamationPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_EXCLAMATION_MARK;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_NOT_EQUAL;
+            Iterator().Forward(1);
+
+            if (Iterator().Peek() == LEX_CHAR_EQUALS) {
+                GetToken().type_ = TokenType::PUNCTUATOR_NOT_STRICT_EQUAL;
+                Iterator().Forward(1);
+            }
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanAmpersandPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_BITWISE_AND;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_AMPERSAND: {
+            GetToken().type_ = TokenType::PUNCTUATOR_LOGICAL_AND;
+            Iterator().Forward(1);
+
+            switch (Iterator().Peek()) {
+                case LEX_CHAR_EQUALS: {
+                    GetToken().type_ = TokenType::PUNCTUATOR_LOGICAL_AND_EQUAL;
+                    Iterator().Forward(1);
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_BITWISE_AND_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanVLinePunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_BITWISE_OR;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_VLINE: {
+            GetToken().type_ = TokenType::PUNCTUATOR_LOGICAL_OR;
+            Iterator().Forward(1);
+
+            switch (Iterator().Peek()) {
+                case LEX_CHAR_EQUALS: {
+                    GetToken().type_ = TokenType::PUNCTUATOR_LOGICAL_OR_EQUAL;
+                    Iterator().Forward(1);
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_BITWISE_OR_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanCircumflexPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_BITWISE_XOR;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanPlusPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_PLUS;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_PLUS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_PLUS_PLUS;
+            Iterator().Forward(1);
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_PLUS_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanMinusPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_MINUS;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_MINUS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_MINUS_MINUS;
+            Iterator().Forward(1);
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_MINUS_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanSlashPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_DIVIDE;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_DIVIDE_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanDotPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_PERIOD;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_0:
+        case LEX_CHAR_1:
+        case LEX_CHAR_2:
+        case LEX_CHAR_3:
+        case LEX_CHAR_4:
+        case LEX_CHAR_5:
+        case LEX_CHAR_6:
+        case LEX_CHAR_7:
+        case LEX_CHAR_8:
+        case LEX_CHAR_9: {
+            ScanNumber();
+            break;
+        }
+        case LEX_CHAR_QUESTION: {
+            GetToken().type_ = TokenType::PUNCTUATOR_PERIOD_QUESTION;
+            Iterator().Forward(1);
+            break;
+        }
+        case LEX_CHAR_DOT: {
+            Iterator().Forward(1);
+
+            if (Iterator().Peek() == LEX_CHAR_DOT) {
+                GetToken().type_ = TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD;
+                Iterator().Forward(1);
+                break;
+            }
+
+            Iterator().Backward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanAsterixPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_MULTIPLY;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_ASTERISK: {
+            GetToken().type_ = TokenType::PUNCTUATOR_EXPONENTIATION;
+            Iterator().Forward(1);
+
+            if (Iterator().Peek() == LEX_CHAR_EQUALS) {
+                GetToken().type_ = TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL;
+                Iterator().Forward(1);
+            }
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_MULTIPLY_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void Lexer::ScanPercentPunctuator()
+{
+    GetToken().type_ = TokenType::PUNCTUATOR_MOD;
+
+    switch (Iterator().Peek()) {
+        case LEX_CHAR_EQUALS: {
+            GetToken().type_ = TokenType::PUNCTUATOR_MOD_EQUAL;
+            Iterator().Forward(1);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+bool Lexer::IsLineTerminatorOrEos() const
+{
+    switch (Iterator().PeekCp()) {
+        case util::StringView::Iterator::INVALID_CP:
+        case LEX_CHAR_LF:
+        case LEX_CHAR_CR:
+        case LEX_CHAR_LS:
+        case LEX_CHAR_PS: {
+            return true;
+        }
+        default: {
+            break;
+        }
+    }
+
+    return false;
+}
+
+void Lexer::ScanRegExpPattern()
+{
+    bool isCharClass = false;
+    size_t cpSize {};
+
+    while (true) {
+        switch (Iterator().PeekCp(&cpSize)) {
+            case util::StringView::Iterator::INVALID_CP:
+            case LEX_CHAR_LF:
+            case LEX_CHAR_CR:
+            case LEX_CHAR_LS:
+            case LEX_CHAR_PS: {
+                ThrowError("Unterminated RegExp");
+                break;
+            }
+            case LEX_CHAR_SLASH: {
+                if (!isCharClass) {
+                    return;
+                }
+
+                break;
+            }
+            case LEX_CHAR_LEFT_SQUARE: {
+                isCharClass = true;
+                break;
+            }
+            case LEX_CHAR_RIGHT_SQUARE: {
+                isCharClass = false;
+                break;
+            }
+            case LEX_CHAR_BACKSLASH: {
+                Iterator().Forward(1);
+
+                if (IsLineTerminatorOrEos()) {
+                    continue;
+                }
+
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
+        Iterator().Forward(cpSize);
+    }
+}
+
+RegExpFlags Lexer::ScanRegExpFlags()
+{
+    RegExpFlags resultFlags = RegExpFlags::EMPTY;
+
+    while (true) {
+        size_t cpSize {};
+        auto cp = Iterator().PeekCp(&cpSize);
+        if (!KeywordsUtil::IsIdentifierPart(cp)) {
+            break;
+        }
+
+        Iterator().Forward(cpSize);
+
+        RegExpFlags flag = RegExpFlags::EMPTY;
+
+        switch (cp) {
+            case LEX_CHAR_LOWERCASE_G: {
+                flag = RegExpFlags::GLOBAL;
+                break;
+            }
+            case LEX_CHAR_LOWERCASE_I: {
+                flag = RegExpFlags::IGNORE_CASE;
+                break;
+            }
+            case LEX_CHAR_LOWERCASE_M: {
+                flag = RegExpFlags::MULTILINE;
+                break;
+            }
+            case LEX_CHAR_LOWERCASE_S: {
+                flag = RegExpFlags::DOTALL;
+                break;
+            }
+            case LEX_CHAR_LOWERCASE_U: {
+                flag = RegExpFlags::UNICODE;
+                break;
+            }
+            case LEX_CHAR_LOWERCASE_Y: {
+                flag = RegExpFlags::STICKY;
+                break;
+            }
+            default: {
+                return resultFlags;
+            }
+        }
+
+        if (flag == RegExpFlags::EMPTY || (resultFlags & flag) != 0) {
+            ThrowError("Invalid RegExp flag");
+        }
+
+        resultFlags = resultFlags | flag;
+    }
+
+    return resultFlags;
+}
+
+RegExp Lexer::ScanRegExp()
+{
+    GetToken().type_ = TokenType::LITERAL_REGEXP;
+
+    const auto patternStart = Iterator().Index();
+    ScanRegExpPattern();
+    const auto pattern = SourceView(patternStart, Iterator().Index());
+
+    ASSERT(Iterator().Peek() == LEX_CHAR_SLASH);
+    Iterator().Forward(1);
+
+    const auto flagsStart = Iterator().Index();
+    RegExpFlags resultFlags = ScanRegExpFlags();
+    const auto flags = SourceView(flagsStart, Iterator().Index());
+
+    SkipWhiteSpaces();
+    SetTokenEnd();
+
+    return {pattern, flags, resultFlags};
+}
+
+bool Lexer::CheckArrow()
+{
+    if (Iterator().Peek() != LEX_CHAR_EQUALS) {
+        return false;
+    }
+    Iterator().Forward(1);
+
+    bool res = Iterator().Peek() == LEX_CHAR_GREATER_THAN;
+    Iterator().Backward(1);
+
+    return res;
+}
+
+void Lexer::SetTokenStart()
+{
+    if (pos_.nextTokenLine != 0) {
+        pos_.line += pos_.nextTokenLine;
+        pos_.nextTokenLine = 0;
+        GetToken().flags_ = TokenFlags::NEW_LINE;
+    } else {
+        GetToken().flags_ = TokenFlags::NONE;
+    }
+
+    pos_.token.loc_.start = SourcePosition {Iterator().Index(), pos_.line};
+}
+
+void Lexer::SetTokenEnd()
+{
+    pos_.token.loc_.end = SourcePosition {Iterator().Index(), pos_.line};
+}
+
+void Lexer::CheckAwaitKeyword()
+{
+    if (!parserContext_->IsAsync()) {
+        GetToken().type_ = TokenType::LITERAL_IDENT;
+        return;
+    }
+
+    if (parserContext_->DisallowAwait()) {
+        ThrowError("'await' is not allowed");
+    }
+
+    GetToken().type_ = TokenType::KEYW_AWAIT;
+}
+
+void Lexer::CheckKeywordEscape(TokenType type)
+{
+    if (GetToken().flags_ & TokenFlags::HAS_ESCAPE) {
+        ThrowError("Escape sequences are not allowed in keywords");
+    }
+
+    GetToken().type_ = type;
+}
+
+void Lexer::CheckEnumKeyword()
+{
+    if (parserContext_->GetProgram()->Extension() == ScriptExtension::JS) {
+        ThrowError("Unexpected reserved keyword");
+    }
+
+    if (GetToken().flags_ & TokenFlags::HAS_ESCAPE) {
+        ThrowError("Escape sequences are not allowed in keywords");
+    }
+
+    GetToken().type_ = TokenType::LITERAL_IDENT;
+}
+
+void Lexer::CheckLetKeyword()
+{
+    GetToken().type_ = TokenType::KEYW_LET;
+}
+
+void Lexer::CheckYieldKeyword()
+{
+    if (!parserContext_->AllowYield()) {
+        ThrowError("'yield' is not allowed");
+    }
+
+    GetToken().type_ = TokenType::KEYW_YIELD;
+}
+
+void Lexer::CheckFutureReservedKeyword(TokenType keywordType)
+{
+    GetToken().type_ = TokenType::LITERAL_IDENT;
+
+    if (parserContext_->GetProgram()->Extension() == ScriptExtension::TS && keywordType <= TokenType::KEYW_INTERFACE) {
+        return;
+    }
+
+    ThrowError("Unexpected strict mode reserved keyword");
+}
+
+void Lexer::SkipWhiteSpaces()
+{
+    while (true) {
+        auto cp = Iterator().Peek();
+
+        switch (cp) {
+            case LEX_CHAR_CR: {
+                Iterator().Forward(1);
+
+                if (Iterator().Peek() != LEX_CHAR_LF) {
+                    Iterator().Backward(1);
+                }
+
+                [[fallthrough]];
+            }
+            case LEX_CHAR_LF: {
+                Iterator().Forward(1);
+                pos_.nextTokenLine++;
+                continue;
+            }
+            case LEX_CHAR_VT:
+            case LEX_CHAR_FF:
+            case LEX_CHAR_SP:
+            case LEX_CHAR_TAB: {
+                Iterator().Forward(1);
+                continue;
+            }
+            case LEX_CHAR_SLASH: {
+                Iterator().Forward(1);
+                cp = Iterator().Peek();
+                if (cp == LEX_CHAR_SLASH) {
+                    Iterator().Forward(1);
+                    SkipSingleLineComment();
+                    continue;
+                }
+                if (cp == LEX_CHAR_ASTERISK) {
+                    Iterator().Forward(1);
+                    SkipMultiLineComment();
+                    continue;
+                }
+
+                Iterator().Backward(1);
+                return;
+            }
+            default: {
+                if (cp < LEX_ASCII_MAX_BITS) {
+                    return;
+                }
+
+                size_t cpSize {};
+                cp = Iterator().PeekCp(&cpSize);
+
+                switch (cp) {
+                    case LEX_CHAR_LS:
+                    case LEX_CHAR_PS: {
+                        pos_.nextTokenLine++;
+                        [[fallthrough]];
+                    }
+                    case LEX_CHAR_NBSP:
+                    case LEX_CHAR_ZWNBSP: {
+                        Iterator().Forward(cpSize);
+                        continue;
+                    }
+                    default: {
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// NOLINTNEXTLINE(readability-function-size)
+void Lexer::NextToken(LexerNextTokenFlags flags)
+{
+    Keywords kws(this, flags);
+    KeywordsUtil &kwu = kws.Util();
+
+    SetTokenStart();
+
+    auto cp = Iterator().Peek();
+    Iterator().Forward(1);
+
+    switch (cp) {
+        case LEX_CHAR_EXCLAMATION: {
+            ScanExclamationPunctuator();
+            break;
+        }
+        case LEX_CHAR_SINGLE_QUOTE: {
+            ScanString<LEX_CHAR_SINGLE_QUOTE>();
+            break;
+        }
+        case LEX_CHAR_DOUBLE_QUOTE: {
+            ScanString<LEX_CHAR_DOUBLE_QUOTE>();
+            break;
+        }
+        case LEX_CHAR_HASH_MARK: {
+            GetToken().type_ = TokenType::PUNCTUATOR_HASH_MARK;
+            break;
+        }
+        case LEX_CHAR_PERCENT: {
+            ScanPercentPunctuator();
+            break;
+        }
+        case LEX_CHAR_AMPERSAND: {
+            ScanAmpersandPunctuator();
+            break;
+        }
+        case LEX_CHAR_LEFT_PAREN: {
+            GetToken().type_ = TokenType::PUNCTUATOR_LEFT_PARENTHESIS;
+            break;
+        }
+        case LEX_CHAR_RIGHT_PAREN: {
+            GetToken().type_ = TokenType::PUNCTUATOR_RIGHT_PARENTHESIS;
+            break;
+        }
+        case LEX_CHAR_ASTERISK: {
+            ScanAsterixPunctuator();
+            break;
+        }
+        case LEX_CHAR_PLUS: {
+            ScanPlusPunctuator();
+            break;
+        }
+        case LEX_CHAR_COMMA: {
+            GetToken().type_ = TokenType::PUNCTUATOR_COMMA;
+            break;
+        }
+        case LEX_CHAR_MINUS: {
+            ScanMinusPunctuator();
+            break;
+        }
+        case LEX_CHAR_DOT: {
+            ScanDotPunctuator();
+            break;
+        }
+        case LEX_CHAR_SLASH: {
+            ScanSlashPunctuator();
+            break;
+        }
+        case LEX_CHAR_0: {
+            ScanNumberLeadingZero();
+            break;
+        }
+        case LEX_CHAR_1:
+        case LEX_CHAR_2:
+        case LEX_CHAR_3:
+        case LEX_CHAR_4:
+        case LEX_CHAR_5:
+        case LEX_CHAR_6:
+        case LEX_CHAR_7:
+        case LEX_CHAR_8:
+        case LEX_CHAR_9: {
+            ScanNumber();
+            break;
+        }
+        case LEX_CHAR_COLON: {
+            GetToken().type_ = TokenType::PUNCTUATOR_COLON;
+            break;
+        }
+        case LEX_CHAR_SEMICOLON: {
+            GetToken().type_ = TokenType::PUNCTUATOR_SEMI_COLON;
+            break;
+        }
+        case LEX_CHAR_LESS_THAN: {
+            ScanLessThanPunctuator();
+            break;
+        }
+        case LEX_CHAR_EQUALS: {
+            ScanEqualsPunctuator();
+            break;
+        }
+        case LEX_CHAR_GREATER_THAN: {
+            ScanGreaterThanPunctuator();
+            break;
+        }
+        case LEX_CHAR_QUESTION: {
+            ScanQuestionPunctuator();
+            break;
+        }
+        case LEX_CHAR_AT: {
+            GetToken().type_ = TokenType::PUNCTUATOR_AT;
+            break;
+        }
+        case LEX_CHAR_DOLLAR_SIGN:
+        case LEX_CHAR_UPPERCASE_A:
+        case LEX_CHAR_UPPERCASE_B:
+        case LEX_CHAR_UPPERCASE_C:
+        case LEX_CHAR_UPPERCASE_D:
+        case LEX_CHAR_UPPERCASE_E:
+        case LEX_CHAR_UPPERCASE_F:
+        case LEX_CHAR_UPPERCASE_G:
+        case LEX_CHAR_UPPERCASE_H:
+        case LEX_CHAR_UPPERCASE_I:
+        case LEX_CHAR_UPPERCASE_J:
+        case LEX_CHAR_UPPERCASE_K:
+        case LEX_CHAR_UPPERCASE_L:
+        case LEX_CHAR_UPPERCASE_M:
+        case LEX_CHAR_UPPERCASE_N:
+        case LEX_CHAR_UPPERCASE_O:
+        case LEX_CHAR_UPPERCASE_P:
+        case LEX_CHAR_UPPERCASE_Q:
+        case LEX_CHAR_UPPERCASE_R:
+        case LEX_CHAR_UPPERCASE_S:
+        case LEX_CHAR_UPPERCASE_T:
+        case LEX_CHAR_UPPERCASE_U:
+        case LEX_CHAR_UPPERCASE_V:
+        case LEX_CHAR_UPPERCASE_W:
+        case LEX_CHAR_UPPERCASE_X:
+        case LEX_CHAR_UPPERCASE_Y:
+        case LEX_CHAR_UPPERCASE_Z:
+        case LEX_CHAR_UNDERSCORE:
+        case LEX_CHAR_LOWERCASE_H:
+        case LEX_CHAR_LOWERCASE_J:
+        case LEX_CHAR_LOWERCASE_Q:
+        case LEX_CHAR_LOWERCASE_X:
+        case LEX_CHAR_LOWERCASE_Z: {
+            kwu.ScanIdContinue();
+            break;
+        }
+        case LEX_CHAR_LEFT_SQUARE: {
+            GetToken().type_ = TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET;
+            break;
+        }
+        case LEX_CHAR_BACKSLASH: {
+            GetToken().flags_ |= TokenFlags::HAS_ESCAPE;
+
+            if (Iterator().Peek() != LEX_CHAR_LOWERCASE_U) {
+                ThrowError("Invalid character");
+            }
+
+            cp = ScanUnicodeEscapeSequence();
+
+            kwu.ScanIdentifierStart(cp);
+            break;
+        }
+        case LEX_CHAR_RIGHT_SQUARE: {
+            GetToken().type_ = TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET;
+            break;
+        }
+        case LEX_CHAR_CIRCUMFLEX: {
+            ScanCircumflexPunctuator();
+            break;
+        }
+        case LEX_CHAR_BACK_TICK: {
+            GetToken().type_ = TokenType::PUNCTUATOR_BACK_TICK;
+            SetTokenEnd();
+            return;
+        }
+        case LEX_CHAR_LOWERCASE_A: {
+            kws.ScanA();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_B: {
+            kws.ScanB();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_C: {
+            kws.ScanC();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_D: {
+            kws.ScanD();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_E: {
+            kws.ScanE();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_F: {
+            kws.ScanF();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_G: {
+            kws.ScanG();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_I: {
+            kws.ScanI();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_K: {
+            kws.ScanK();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_L: {
+            kws.ScanL();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_M: {
+            kws.ScanM();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_N: {
+            kws.ScanN();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_O: {
+            kws.ScanO();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_P: {
+            kws.ScanP();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_R: {
+            kws.ScanR();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_S: {
+            kws.ScanS();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_T: {
+            kws.ScanT();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_U: {
+            kws.ScanU();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_V: {
+            kws.ScanV();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_W: {
+            kws.ScanW();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_Y: {
+            kws.ScanY();
+            break;
+        }
+        case LEX_CHAR_LEFT_BRACE: {
+            GetToken().type_ = TokenType::PUNCTUATOR_LEFT_BRACE;
+
+            if (tlCtx_) {
+                tlCtx_->ConsumeLeftBrace();
+            }
+
+            break;
+        }
+        case LEX_CHAR_VLINE: {
+            ScanVLinePunctuator();
+            break;
+        }
+        case LEX_CHAR_RIGHT_BRACE: {
+            GetToken().type_ = TokenType::PUNCTUATOR_RIGHT_BRACE;
+
+            if (tlCtx_ && tlCtx_->ConsumeRightBrace()) {
+                SetTokenEnd();
+                return;
+            }
+
+            break;
+        }
+        case LEX_CHAR_TILDE: {
+            GetToken().type_ = TokenType::PUNCTUATOR_TILDE;
+            break;
+        }
+        default: {
+            Iterator().Backward(1);
+
+            if (cp == util::StringView::Iterator::INVALID_CP) {
+                GetToken().type_ = TokenType::EOS;
+                break;
+            }
+
+            cp = Iterator().Next();
+            kwu.ScanIdentifierStart(cp);
+            break;
+        }
+    }
+
+    SetTokenEnd();
+    SkipWhiteSpaces();
+}
+
+}  // namespace panda::es2panda::lexer
diff --git a/es2panda/lexer/lexer.h b/es2panda/lexer/lexer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8302270254e34d7535b8cc14df7819cea242c25
--- /dev/null
+++ b/es2panda/lexer/lexer.h
@@ -0,0 +1,438 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_LEXER_H
+#define ES2PANDA_PARSER_CORE_LEXER_H
+
+#include <lexer/regexp/regexp.h>
+#include <lexer/token/letters.h>
+#include <lexer/token/token.h>
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::parser {
+class ParserContext;
+}  // namespace panda::es2panda::parser
+
+namespace panda::es2panda::lexer {
+
+enum class LexerNextTokenFlags {
+    NONE = 0,
+    KEYWORD_TO_IDENT = 1 << 0,
+    NUMERIC_SEPARATOR_ALLOWED = 1 << 1,
+    BIGINT_ALLOWED = 1 << 2,
+};
+
+DEFINE_BITOPS(LexerNextTokenFlags)
+
+class LexerPosition {
+public:
+    explicit LexerPosition(const util::StringView &source);
+    DEFAULT_COPY_SEMANTIC(LexerPosition);
+    DEFAULT_MOVE_SEMANTIC(LexerPosition);
+    ~LexerPosition() = default;
+
+    Token token {};
+    util::StringView::Iterator iterator;
+    size_t line {};
+    size_t nextTokenLine {};
+};
+
+class LexerTemplateString {
+public:
+    explicit LexerTemplateString(ArenaAllocator *allocator) : str(allocator) {}
+    DEFAULT_COPY_SEMANTIC(LexerTemplateString);
+    DEFAULT_MOVE_SEMANTIC(LexerTemplateString);
+    ~LexerTemplateString() = default;
+
+    util::UString str;
+    size_t end {};
+    bool scanExpression {};
+};
+
+class TemplateLiteralParserContext;
+
+class Lexer {
+public:
+    explicit Lexer(const parser::ParserContext *parserContext);
+    NO_COPY_SEMANTIC(Lexer);
+    NO_MOVE_SEMANTIC(Lexer);
+    ~Lexer() = default;
+
+    void NextToken(LexerNextTokenFlags flags = LexerNextTokenFlags::NONE);
+
+    Token &GetToken();
+    const Token &GetToken() const;
+    size_t Line() const;
+
+    LexerPosition Save() const;
+    void Rewind(const LexerPosition &pos);
+    void BackwardToken(TokenType type, size_t offset);
+    void ForwardToken(TokenType type, size_t offset);
+
+    char32_t Lookahead();
+    bool CheckArrow();
+
+    RegExp ScanRegExp();
+    template <char32_t end>
+    void ScanString();
+    void ResetTokenEnd();
+    LexerTemplateString ScanTemplateString();
+    void ScanTemplateStringEnd();
+    void PushTemplateContext(TemplateLiteralParserContext *ctx);
+
+private:
+    ArenaAllocator *Allocator();
+    bool IsLineTerminatorOrEos() const;
+    void ScanRegExpPattern();
+    RegExpFlags ScanRegExpFlags();
+
+    void ThrowError(std::string_view message);
+
+    void SetTokenStart();
+    void SetTokenEnd();
+
+    inline util::StringView::Iterator &Iterator()
+    {
+        return pos_.iterator;
+    }
+
+    inline const util::StringView::Iterator &Iterator() const
+    {
+        return pos_.iterator;
+    }
+
+    util::StringView SourceView(const util::StringView::Iterator &begin, const util::StringView::Iterator &end) const;
+    util::StringView SourceView(size_t begin, size_t end) const;
+
+    void SkipWhiteSpaces();
+    void SkipSingleLineComment();
+    void SkipMultiLineComment();
+    template <TokenType keyword_type>
+    void CheckKeyword([[maybe_unused]] TokenType type, [[maybe_unused]] LexerNextTokenFlags flags);
+    void CheckKeywordEscape(TokenType type);
+    void CheckAwaitKeyword();
+    void CheckEnumKeyword();
+    void CheckLetKeyword();
+    void CheckYieldKeyword();
+    void CheckFutureReservedKeyword(TokenType keywordType);
+
+    bool ScanPunctuator();
+    void ScanQuestionPunctuator();
+    void ScanLessThanPunctuator();
+    void ScanGreaterThanPunctuator();
+    void ScanEqualsPunctuator();
+    void ScanExclamationPunctuator();
+    void ScanAmpersandPunctuator();
+    void ScanVLinePunctuator();
+    void ScanCircumflexPunctuator();
+    void ScanPlusPunctuator();
+    void ScanMinusPunctuator();
+    void ScanAsterixPunctuator();
+    void ScanSlashPunctuator();
+    void ScanPercentPunctuator();
+    void ScanDotPunctuator();
+
+    char32_t ScanUnicodeEscapeSequence();
+    template <int N>
+    char32_t ScanHexEscape();
+    char32_t ScanUnicodeCodePointEscape();
+
+    void ScanStringUnicodePart(util::UString *str);
+
+    void ScanNumberLeadingZero();
+    void ScanDecimalNumbers(bool allowNumericSeparator);
+    template <bool rangeCheck(char32_t), int radix>
+    void ScanNumberRadix(bool allowNumericSeparator = true);
+    void ScanNumber(bool allowNumericSeparator = true, bool allowBigInt = true);
+    void ConvertNumber(size_t exponentSignPos);
+    void ScanDecimalLiteral();
+    void ScanDecimalDigits(bool allowNumericSeparator);
+    void CheckNumberLiteralEnd();
+
+    inline static uint32_t HexValue(char32_t ch);
+    inline static bool IsDecimalDigit(uint32_t cp);
+    inline static bool IsHexDigit(char32_t ch);
+    inline static bool IsBinaryDigit(char32_t ch);
+    inline static bool IsOctalDigit(char32_t ch);
+
+    friend class KeywordsUtil;
+    friend class TemplateLiteralParserContext;
+    TemplateLiteralParserContext *tlCtx_ {};
+    ArenaAllocator *allocator_;
+    const parser::ParserContext *parserContext_;
+    util::StringView source_;
+    LexerPosition pos_;
+};
+
+class TemplateLiteralParserContext {
+public:
+    explicit TemplateLiteralParserContext(Lexer *lexer) : lexer_(lexer), prev_(lexer_->tlCtx_) {}
+    NO_MOVE_SEMANTIC(TemplateLiteralParserContext);
+    NO_COPY_SEMANTIC(TemplateLiteralParserContext);
+
+    ~TemplateLiteralParserContext()
+    {
+        lexer_->tlCtx_ = prev_;
+    }
+
+    void ConsumeLeftBrace()
+    {
+        braceDepth_++;
+    }
+
+    bool ConsumeRightBrace()
+    {
+        braceDepth_--;
+
+        return braceDepth_ == 0;
+    }
+
+private:
+    Lexer *lexer_;
+    TemplateLiteralParserContext *prev_ {};
+    size_t braceDepth_ {1};
+};
+
+template <char32_t end>
+void Lexer::ScanString()
+{
+    util::UString str(Allocator());
+    GetToken().type_ = TokenType::LITERAL_STRING;
+
+    const auto startPos = Iterator().Index();
+    auto escapeEnd = startPos;
+
+    do {
+        char32_t cp = Iterator().Peek();
+
+        switch (cp) {
+            case util::StringView::Iterator::INVALID_CP: {
+                ThrowError("Unterminated string");
+                break;
+            }
+            case LEX_CHAR_CR:
+            case LEX_CHAR_LF: {
+                // NOLINTNEXTLINE(readability-braces-around-statements,bugprone-suspicious-semicolon)
+                if constexpr (end != LEX_CHAR_BACK_TICK) {
+                    ThrowError("Newline is not allowed in strings");
+                }
+
+                GetToken().flags_ |= TokenFlags::HAS_ESCAPE;
+                str.Append(SourceView(escapeEnd, Iterator().Index()));
+
+                if (cp == LEX_CHAR_CR) {
+                    Iterator().Forward(1);
+
+                    if (Iterator().Peek() != LEX_CHAR_LF) {
+                        Iterator().Backward(1);
+                    }
+                }
+
+                pos_.line++;
+                str.Append(LEX_CHAR_LF);
+                Iterator().Forward(1);
+                escapeEnd = Iterator().Index();
+                continue;
+            }
+            case LEX_CHAR_BACKSLASH: {
+                GetToken().flags_ |= TokenFlags::HAS_ESCAPE;
+                str.Append(SourceView(escapeEnd, Iterator().Index()));
+
+                Iterator().Forward(1);
+                ScanStringUnicodePart(&str);
+                escapeEnd = Iterator().Index();
+                continue;
+            }
+            case LEX_CHAR_BACK_TICK:
+            case LEX_CHAR_SINGLE_QUOTE:
+            case LEX_CHAR_DOUBLE_QUOTE: {
+                if (end == cp) {
+                    break;
+                }
+
+                Iterator().Forward(1);
+                continue;
+            }
+            case LEX_CHAR_DOLLAR_SIGN: {
+                Iterator().Forward(1);
+
+                // NOLINTNEXTLINE(readability-braces-around-statements,bugprone-suspicious-semicolon)
+                if constexpr (end == LEX_CHAR_BACK_TICK) {
+                    if (Iterator().Peek() == LEX_CHAR_LEFT_BRACE) {
+                        Iterator().Backward(1);
+                        break;
+                    }
+                }
+
+                continue;
+            }
+            default: {
+                Iterator().SkipCp();
+                continue;
+            }
+        }
+
+        if (GetToken().flags_ & TokenFlags::HAS_ESCAPE) {
+            str.Append(SourceView(escapeEnd, Iterator().Index()));
+            GetToken().src_ = str.View();
+        } else {
+            GetToken().src_ = SourceView(startPos, Iterator().Index());
+        }
+
+        break;
+    } while (true);
+
+    // NOLINTNEXTLINE(readability-braces-around-statements,bugprone-suspicious-semicolon)
+    if constexpr (end != LEX_CHAR_BACK_TICK) {
+        Iterator().Forward(1);
+    }
+}
+
+template <int N>
+char32_t Lexer::ScanHexEscape()
+{
+    char32_t code = 0;
+
+    for (size_t i = 0; i < N; ++i) {
+        const auto cp = Iterator().Peek();
+        Iterator().Forward(1);
+
+        if (!IsHexDigit(cp)) {
+            ThrowError("Invalid unicode escape sequence");
+        }
+
+        constexpr auto MULTIPLIER = 16;
+        code = code * MULTIPLIER + HexValue(cp);
+    }
+
+    return code;
+}
+
+template <bool rangeCheck(char32_t), int radix>
+void Lexer::ScanNumberRadix(bool allowNumericSeparator)
+{
+    double number = 0.0;
+
+    auto cp = Iterator().Peek();
+    if (!rangeCheck(cp)) {
+        ThrowError("Invalid digit");
+    }
+
+    bool allowNumericOnNext = true;
+
+    do {
+        cp = Iterator().Peek();
+        if (rangeCheck(cp)) {
+            number = number * radix + HexValue(cp);
+            Iterator().Forward(1);
+            allowNumericOnNext = true;
+            continue;
+        }
+
+        if (cp == LEX_CHAR_UNDERSCORE) {
+            if (!allowNumericSeparator || !allowNumericOnNext) {
+                ThrowError("Invalid numeric separator");
+            }
+
+            GetToken().flags_ |= TokenFlags::NUMBER_HAS_UNDERSCORE;
+            Iterator().Forward(1);
+            allowNumericOnNext = false;
+            continue;
+        }
+
+        if (!allowNumericOnNext) {
+            Iterator().Backward(1);
+            ThrowError("Numeric separators are not allowed at the end of numeric literals");
+        }
+
+        break;
+    } while (true);
+
+    GetToken().number_ = number;
+}
+
+template <TokenType keyword_type>
+void Lexer::CheckKeyword([[maybe_unused]] TokenType type, [[maybe_unused]] LexerNextTokenFlags flags)
+{
+    // NOLINTNEXTLINE
+    if constexpr (keyword_type == TokenType::KEYW_AWAIT) {
+        CheckAwaitKeyword();
+        return;
+    }
+
+    // NOLINTNEXTLINE
+    if constexpr (keyword_type == TokenType::KEYW_ENUM) {
+        CheckEnumKeyword();
+        return;
+    }
+
+    // NOLINTNEXTLINE
+    if constexpr (keyword_type == TokenType::KEYW_YIELD) {
+        CheckYieldKeyword();
+        return;
+    }
+
+    // NOLINTNEXTLINE
+    if constexpr (keyword_type == TokenType::KEYW_LET) {
+        CheckLetKeyword();
+        return;
+    }
+
+    // NOLINTNEXTLINE
+    if constexpr (keyword_type <= TokenType::KEYW_ASYNC) {
+        CheckKeywordEscape(type);
+        return;
+    }
+
+    // NOLINTNEXTLINE
+    if constexpr (keyword_type >= TokenType::KEYW_PUBLIC) {
+        // NOLINTNEXTLINE
+        CheckFutureReservedKeyword(keyword_type);
+        return;
+    }
+
+    GetToken().type_ = TokenType::LITERAL_IDENT;
+}
+
+inline uint32_t Lexer::HexValue(char32_t ch)
+{
+    constexpr uint32_t HEX_MASK = 0xF;
+    constexpr uint32_t DEC_OFFSET = 10;
+    return ch < LEX_CHAR_UPPERCASE_A ? ch - LEX_CHAR_0 : ((ch - LEX_CHAR_UPPERCASE_A + DEC_OFFSET) & HEX_MASK);
+}
+
+inline bool Lexer::IsDecimalDigit(uint32_t cp)
+{
+    return (cp >= LEX_CHAR_0 && cp <= LEX_CHAR_9);
+}
+
+inline bool Lexer::IsHexDigit(char32_t ch)
+{
+    return ch < LEX_ASCII_MAX_BITS && std::isxdigit(static_cast<unsigned char>(ch));
+}
+
+inline bool Lexer::IsBinaryDigit(char32_t ch)
+{
+    return ch == LEX_CHAR_0 || ch == LEX_CHAR_1;
+}
+
+inline bool Lexer::IsOctalDigit(char32_t ch)
+{
+    return (ch >= LEX_CHAR_0 && ch <= LEX_CHAR_7);
+}
+
+}  // namespace panda::es2panda::lexer
+
+#endif
diff --git a/es2panda/lexer/regexp/regexp.cpp b/es2panda/lexer/regexp/regexp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7058ffc8eac32fa5cf216ab7e11c02fc044d1519
--- /dev/null
+++ b/es2panda/lexer/regexp/regexp.cpp
@@ -0,0 +1,870 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "regexp.h"
+
+#include <lexer/token/letters.h>
+#include <unicode/uchar.h>
+
+#include <iostream>
+
+namespace panda::es2panda::lexer {
+
+RegExpError::RegExpError(std::string_view m) : message(m) {}
+
+RegExp::RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags) : patternStr(p), flagsStr(f), flags(reFlags)
+{
+}
+
+RegExpParser::RegExpParser(const RegExp &re, ArenaAllocator *allocator)
+    : re_(re), allocator_ {allocator}, iter_(re_.patternStr), capturingGroupCount_(0)
+{
+}
+
+bool RegExpParser::Unicode() const
+{
+    return (re_.flags & RegExpFlags::UNICODE) != 0;
+}
+
+char32_t RegExpParser::Peek() const
+{
+    return iter_.Peek();
+}
+
+char32_t RegExpParser::Next()
+{
+    return iter_.Next();
+}
+
+static bool IsDecimalDigit(char32_t cp)
+{
+    return (cp >= LEX_CHAR_0 && cp <= LEX_CHAR_9);
+}
+
+static bool IsOctalDigit(char32_t cp)
+{
+    return (cp >= LEX_CHAR_0 && cp <= LEX_CHAR_7);
+}
+
+static bool IsHexDigit(char32_t cp)
+{
+    return IsDecimalDigit(cp) || (cp >= LEX_CHAR_LOWERCASE_A && cp <= LEX_CHAR_LOWERCASE_F) ||
+           (cp >= LEX_CHAR_UPPERCASE_A && cp <= LEX_CHAR_UPPERCASE_F);
+}
+
+static uint32_t DigitValue(char32_t cp)
+{
+    return (cp - LEX_CHAR_0);
+}
+
+static uint32_t HexValue(char32_t cp)
+{
+    if (IsDecimalDigit(cp)) {
+        return DigitValue(cp);
+    }
+
+    constexpr auto OFFSET = 10;
+
+    if (cp < LEX_CHAR_LOWERCASE_A) {
+        return cp - LEX_CHAR_UPPERCASE_A + OFFSET;
+    }
+
+    return (cp - LEX_CHAR_LOWERCASE_A + OFFSET);
+}
+
+static void ThrowError(std::string_view message)
+{
+    throw RegExpError(message);
+}
+
+void RegExpParser::ParsePattern()
+{
+    ParseDisjunction();
+
+    if (iter_.HasNext()) {
+        ThrowError("Invalid closing parenthesis");
+    }
+}
+
+void RegExpParser::ParseDisjunction()
+{
+    while (true) {
+        ParseAlternatives();
+
+        if (Peek() != LEX_CHAR_VLINE) {
+            break;
+        }
+
+        Next();
+    };
+}
+
+void RegExpParser::ParseAlternative()
+{
+    switch (Peek()) {
+        case LEX_CHAR_BACKSLASH: {
+            Next();
+            char32_t cp = Peek();
+            if (cp == LEX_CHAR_LOWERCASE_B || cp == LEX_CHAR_UPPERCASE_B) {
+                /* assertion */
+                Next();
+                return;
+            }
+
+            ParseAtomEscape();
+            break;
+        }
+        case LEX_CHAR_CIRCUMFLEX:
+        case LEX_CHAR_DOLLAR_SIGN: {
+            /* assertion */
+            Next();
+            return;
+        }
+        case LEX_CHAR_LEFT_PAREN: {
+            Next();
+
+            if (Peek() != LEX_CHAR_QUESTION) {
+                ParseCapturingGroup();
+                break;
+            }
+
+            Next();  // eat '?'
+
+            char32_t cp = Next();
+            if (cp == LEX_CHAR_COLON) {
+                ParseNonCapturingGroup();
+                break;
+            }
+
+            if (cp == LEX_CHAR_EQUALS || cp == LEX_CHAR_EXCLAMATION) {
+                ParseAssertion();
+
+                if (Unicode()) {
+                    return;
+                }
+
+                break;
+            }
+
+            if (cp != LEX_CHAR_LESS_THAN) {
+                ThrowError("Invalid group");
+            }
+
+            cp = Peek();
+            if (cp == LEX_CHAR_EQUALS || cp == LEX_CHAR_EXCLAMATION) {
+                Next();
+                ParseAssertion();
+                return;
+            }
+
+            ParseNamedCapturingGroup();
+            break;
+        }
+        case LEX_CHAR_LEFT_SQUARE: {
+            Next();
+            ParseCharacterClass();
+            break;
+        }
+        case LEX_CHAR_DOT: {
+            Next();
+            break;
+        }
+        default: {
+            if (ParseBracedQuantifier()) {
+                ThrowError("Invalid quantifier, nothing to repeat");
+            }
+
+            if (!ParsePatternCharacter()) {
+                ThrowError("Invalid character");
+            }
+
+            break;
+        }
+    }
+
+    ParseQuantifier();
+}
+
+void RegExpParser::ParseAlternatives()
+{
+    while (true) {
+        switch (Peek()) {
+            case util::StringView::Iterator::INVALID_CP:
+            case LEX_CHAR_RIGHT_PAREN:
+            case LEX_CHAR_VLINE: {
+                return;
+            }
+            default: {
+                ParseAlternative();
+            }
+        }
+    }
+}
+
+void RegExpParser::ParseNonCapturingGroup()
+{
+    ParseDisjunction();
+
+    if (Peek() != LEX_CHAR_RIGHT_PAREN) {
+        ThrowError("Invalid non-capturing group");
+    }
+
+    Next();
+}
+
+void RegExpParser::ParseNamedCapturingGroup()
+{
+    util::StringView name = ParseIdent();
+
+    auto result = groupNames_.insert(name);
+    if (!result.second) {
+        ThrowError("Duplicate group name");
+    }
+
+    ParseCapturingGroup();
+}
+
+void RegExpParser::ParseCapturingGroup()
+{
+    capturingGroupCount_++;
+
+    ParseDisjunction();
+
+    if (Peek() != LEX_CHAR_RIGHT_PAREN) {
+        ThrowError("Invalid capturing group");
+    }
+
+    Next();
+}
+
+void RegExpParser::ParseAssertion()
+{
+    ParseDisjunction();
+
+    if (Peek() != LEX_CHAR_RIGHT_PAREN) {
+        ThrowError("Invalid assertion");
+    }
+
+    Next();
+}
+
+uint32_t RegExpParser::ParseControlEscape()
+{
+    char32_t cp = Peek();
+    if ((cp < LEX_CHAR_LOWERCASE_A || cp > LEX_CHAR_LOWERCASE_Z) &&
+        (cp < LEX_CHAR_UPPERCASE_A || cp > LEX_CHAR_UPPERCASE_Z)) {
+        if (Unicode()) {
+            ThrowError("Invalid control escape");
+        }
+
+        if (cp < LEX_CHAR_0 || cp > LEX_CHAR_9) {
+            return LEX_CHAR_LOWERCASE_C;
+        }
+    }
+
+    Next();
+    constexpr auto MODULO = 32;
+    return cp % MODULO;
+}
+
+char32_t RegExpParser::ParseClassAtom()
+{
+    char32_t cp = Next();
+    if (cp != LEX_CHAR_BACKSLASH) {
+        return cp;
+    }
+
+    cp = Peek();
+    if (cp == LEX_CHAR_0) {
+        if (!Unicode()) {
+            return ParseDecimalEscape();
+        }
+
+        Next();
+
+        if (IsDecimalDigit(Peek())) {
+            ThrowError("Invalid class escape");
+        }
+
+        return LEX_CHAR_NULL;
+    }
+
+    Next();
+
+    switch (cp) {
+        case LEX_CHAR_LOWERCASE_C: {
+            return ParseControlEscape();
+        }
+        case LEX_CHAR_LOWERCASE_X: {
+            return ParseHexEscape();
+        }
+        case LEX_CHAR_LOWERCASE_U: {
+            if (!Unicode() && Peek() == LEX_CHAR_LEFT_BRACE) {
+                return cp;
+            }
+
+            return ParseUnicodeEscape();
+        }
+        case LEX_CHAR_LOWERCASE_P:
+        case LEX_CHAR_UPPERCASE_P: {
+            if (!Unicode()) {
+                return cp;
+            }
+
+            ParseUnicodePropertyEscape();
+            [[fallthrough]];
+        }
+        case LEX_CHAR_LOWERCASE_D:
+        case LEX_CHAR_UPPERCASE_D:
+        case LEX_CHAR_LOWERCASE_S:
+        case LEX_CHAR_UPPERCASE_S:
+        case LEX_CHAR_LOWERCASE_W:
+        case LEX_CHAR_UPPERCASE_W: {
+            return std::numeric_limits<uint32_t>::max();
+        }
+        case LEX_CHAR_LOWERCASE_B: {
+            return LEX_CHAR_BS;
+        }
+        case LEX_CHAR_LOWERCASE_F: {
+            return LEX_CHAR_FF;
+        }
+        case LEX_CHAR_LOWERCASE_N: {
+            return LEX_CHAR_LF;
+        }
+        case LEX_CHAR_LOWERCASE_R: {
+            return LEX_CHAR_CR;
+        }
+        case LEX_CHAR_LOWERCASE_T: {
+            return LEX_CHAR_TAB;
+        }
+        case LEX_CHAR_LOWERCASE_V: {
+            return LEX_CHAR_VT;
+        }
+        case LEX_CHAR_MINUS: {
+            return cp;
+        }
+        default: {
+            if (Unicode() && !IsSyntaxCharacter(cp) && cp != LEX_CHAR_SLASH) {
+                ThrowError("Invalid escape");
+            }
+
+            return cp;
+        }
+    }
+
+    return cp;
+}
+
+static bool IsClassEscape(uint32_t cp)
+{
+    return cp == std::numeric_limits<uint32_t>::max();
+}
+
+void RegExpParser::ParseCharacterClass()
+{
+    if (Peek() == LEX_CHAR_CIRCUMFLEX) {
+        Next();
+    }
+
+    while (true) {
+        if (Peek() == LEX_CHAR_RIGHT_SQUARE) {
+            Next();
+            break;
+        }
+
+        uint32_t left = ParseClassAtom();
+
+        if (Peek() != LEX_CHAR_MINUS) {
+            continue;
+        }
+
+        Next();
+
+        if (Peek() == LEX_CHAR_RIGHT_SQUARE) {
+            Next();
+            break;
+        }
+
+        uint32_t right = ParseClassAtom();
+        if ((IsClassEscape(left) || IsClassEscape(right))) {
+            if (Unicode()) {
+                ThrowError("Invalid character class");
+            }
+
+            continue;
+        }
+
+        if (left > right) {
+            ThrowError("Class range out of order");
+        }
+    }
+}
+
+bool RegExpParser::IsSyntaxCharacter(char32_t cp) const
+{
+    switch (cp) {
+        case LEX_CHAR_RIGHT_SQUARE:
+        case LEX_CHAR_LEFT_BRACE:
+        case LEX_CHAR_RIGHT_BRACE: {
+            if (!Unicode()) {
+                return false;
+            }
+
+            [[fallthrough]];
+        }
+        case LEX_CHAR_CIRCUMFLEX:
+        case LEX_CHAR_DOLLAR_SIGN:
+        case LEX_CHAR_BACKSLASH:
+        case LEX_CHAR_DOT:
+        case LEX_CHAR_ASTERISK:
+        case LEX_CHAR_PLUS:
+        case LEX_CHAR_QUESTION:
+        case LEX_CHAR_LEFT_PAREN:
+        case LEX_CHAR_RIGHT_PAREN:
+        case LEX_CHAR_LEFT_SQUARE:
+        case LEX_CHAR_VLINE: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+
+void RegExpParser::ParseAtomEscape()
+{
+    char32_t cp = Peek();
+    if (IsDecimalDigit(cp)) {
+        ParseDecimalEscape();
+        return;
+    }
+
+    Next();
+
+    switch (cp) {
+        case LEX_CHAR_LOWERCASE_X: {
+            ParseHexEscape();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_U: {
+            ParseUnicodeEscape();
+            break;
+        }
+        case LEX_CHAR_LOWERCASE_K: {
+            ParseNamedBackreference();
+            return;
+        }
+        /* ControlEscape */
+        case LEX_CHAR_LOWERCASE_F:
+        case LEX_CHAR_LOWERCASE_N:
+        case LEX_CHAR_LOWERCASE_R:
+        case LEX_CHAR_LOWERCASE_T:
+        case LEX_CHAR_LOWERCASE_V:
+        /* CharacterClassEscape */
+        case LEX_CHAR_LOWERCASE_D:
+        case LEX_CHAR_UPPERCASE_D:
+        case LEX_CHAR_LOWERCASE_S:
+        case LEX_CHAR_UPPERCASE_S:
+        case LEX_CHAR_LOWERCASE_W:
+        case LEX_CHAR_UPPERCASE_W: {
+            return;
+        }
+        case LEX_CHAR_LOWERCASE_P:
+        case LEX_CHAR_UPPERCASE_P: {
+            ParseUnicodePropertyEscape();
+            return;
+        }
+        case LEX_CHAR_LOWERCASE_C: {
+            cp = Peek();
+            if ((cp < LEX_CHAR_LOWERCASE_A || cp > LEX_CHAR_LOWERCASE_Z) &&
+                (cp < LEX_CHAR_UPPERCASE_A || cp > LEX_CHAR_UPPERCASE_Z)) {
+                ThrowError("Invalid control escape");
+            }
+
+            Next();
+            return;
+        }
+        default: {
+            /* IdentityEscape */
+            if (Unicode() && !IsSyntaxCharacter(cp) && cp != LEX_CHAR_SLASH) {
+                ThrowError("Invalid escape");
+            }
+        }
+    }
+}
+
+uint32_t RegExpParser::ParseDecimalEscape()
+{
+    ASSERT(IsDecimalDigit(Peek()));
+
+    auto digitStart = iter_;
+    uint32_t decimalValue = DigitValue(Next());
+    if (decimalValue == 0) {
+        if (!IsDecimalDigit(Peek())) {
+            /* \0 */
+            return decimalValue;
+        }
+
+        if (Unicode()) {
+            ThrowError("Invalid decimal escape");
+        }
+
+        iter_ = digitStart;
+        return ParseLegacyOctalEscape();
+    }
+
+    constexpr auto MULTIPLIER = 10;
+
+    while (IsDecimalDigit(Peek())) {
+        uint32_t newValue = decimalValue * MULTIPLIER + DigitValue(Next());
+        if (newValue < decimalValue) {
+            ThrowError("Invalid decimal escape");
+        }
+
+        decimalValue = newValue;
+    }
+
+    if (decimalValue <= capturingGroupCount_) {
+        return decimalValue;
+    }
+
+    if (Unicode()) {
+        ThrowError("Invalid decimal escape");
+    }
+
+    iter_ = digitStart;
+
+    if (!IsOctalDigit(Peek())) {
+        /* \8 or \9 */
+        return DigitValue(Next());
+    }
+
+    return ParseLegacyOctalEscape();
+}
+
+uint32_t RegExpParser::ParseLegacyOctalEscape()
+{
+    ASSERT(IsOctalDigit(Peek()));
+    uint32_t octalValue = DigitValue(Next());
+
+    if (!IsOctalDigit(Peek())) {
+        return octalValue;
+    }
+
+    octalValue = octalValue * 8 + DigitValue(Next());
+
+    if (!IsOctalDigit(Peek())) {
+        return octalValue;
+    }
+
+    uint32_t newValue = octalValue * 8 + DigitValue(Peek());
+    constexpr uint32_t MAX_OCTAL_VALUE = 0xFF;
+
+    if (newValue <= MAX_OCTAL_VALUE) {
+        octalValue = newValue;
+        Next();
+    }
+
+    return octalValue;
+}
+
+uint32_t RegExpParser::ParseHexEscape()
+{
+    char32_t digit = Next();
+    if (!IsHexDigit(digit)) {
+        ThrowError("Invalid hex escape");
+    }
+
+    constexpr auto MULTIPLIER = 16;
+    uint32_t cpValue = HexValue(digit) * MULTIPLIER;
+
+    digit = Next();
+    if (!IsHexDigit(digit)) {
+        ThrowError("Invalid hex escape");
+    }
+
+    cpValue += HexValue(digit);
+    return cpValue;
+}
+
+uint32_t RegExpParser::ParseUnicodeDigits()
+{
+    uint32_t value = 0;
+    uint32_t count = 4;
+
+    while (count--) {
+        char32_t digit = Next();
+        if (!IsHexDigit(digit)) {
+            ThrowError("Invalid Unicode escape");
+        }
+
+        constexpr auto MULTIPLIER = 16;
+        value = value * MULTIPLIER + HexValue(digit);
+    }
+
+    return value;
+}
+
+uint32_t RegExpParser::ParseUnicodeEscape()
+{
+    uint32_t value = 0;
+
+    if (Peek() == LEX_CHAR_LEFT_BRACE) {
+        Next();
+        if (!IsHexDigit(Peek())) {
+            ThrowError("Invalid Unicode escape");
+        }
+
+        while (IsHexDigit(Peek())) {
+            constexpr auto MULTIPLIER = 16;
+            value = value * MULTIPLIER + HexValue(Next());
+            constexpr uint32_t CODE_POINT_MAX = 0x10FFFF;
+
+            if (value > CODE_POINT_MAX) {
+                ThrowError("Invalid Unicode escape");
+            }
+        }
+
+        if (Peek() != LEX_CHAR_RIGHT_BRACE) {
+            ThrowError("Invalid Unicode escape");
+        }
+
+        Next();
+    } else {
+        value = ParseUnicodeDigits();
+        if (util::StringView::IsHighSurrogate(value)) {
+            auto pos = iter_;
+
+            if (Next() == LEX_CHAR_BACKSLASH && Next() == LEX_CHAR_LOWERCASE_U) {
+                uint32_t next = ParseUnicodeDigits();
+                if (util::StringView::IsLowSurrogate(next)) {
+                    return util::StringView::DecodeSurrogates(value, next);
+                }
+            }
+
+            iter_ = pos;
+        }
+    }
+
+    return value;
+}
+
+void RegExpParser::ParseUnicodePropertyEscape()
+{
+    if (!Unicode()) {
+        return;
+    }
+
+    if (Peek() != LEX_CHAR_LEFT_BRACE) {
+        ThrowError("Invalid Unicode property escape");
+    }
+
+    Next();
+
+    while (true) {
+        if (!iter_.HasNext()) {
+            ThrowError("Unterminated Unicode property escape");
+        }
+
+        char32_t ch = Next();
+        if (ch == LEX_CHAR_LEFT_BRACE) {
+            break;
+        }
+
+        /* TODO(dbatyai): Parse and valide Unicode property names */
+    }
+}
+
+void RegExpParser::ParseNamedBackreference()
+{
+    if (groupNames_.empty()) {
+        /* Identity escape */
+        return;
+    }
+
+    if (Next() != LEX_CHAR_LESS_THAN) {
+        ThrowError("Invalid named backreference");
+    }
+
+    util::StringView name = ParseIdent();
+
+    auto result = groupNames_.find(name);
+    if (result == groupNames_.end()) {
+        ThrowError("Invalid named capture referenced");
+    }
+}
+
+void RegExpParser::ParseQuantifier()
+{
+    switch (Peek()) {
+        case LEX_CHAR_ASTERISK:
+        case LEX_CHAR_PLUS:
+        case LEX_CHAR_QUESTION: {
+            Next();
+            break;
+        }
+        case LEX_CHAR_LEFT_BRACE: {
+            if (!ParseBracedQuantifier()) {
+                return;
+            }
+
+            break;
+        }
+        default: {
+            return;
+        }
+    }
+
+    if (Peek() == LEX_CHAR_QUESTION) {
+        Next();
+    }
+}
+
+bool RegExpParser::ParseBracedQuantifier()
+{
+    if (Peek() != LEX_CHAR_LEFT_BRACE) {
+        return false;
+    }
+
+    auto startPos = iter_;
+    Next();
+
+    if (!IsDecimalDigit(Peek())) {
+        iter_ = startPos;
+        return false;
+    }
+
+    uint32_t leftValue = 0;
+    constexpr auto MULTIPLIER = 10;
+
+    while (IsDecimalDigit(Peek())) {
+        uint32_t newValue = leftValue * MULTIPLIER + DigitValue(Next());
+        if (newValue < leftValue) {
+            leftValue = std::numeric_limits<uint32_t>::max();
+            continue;
+        }
+
+        leftValue = newValue;
+    }
+
+    if (Peek() == LEX_CHAR_COMMA) {
+        Next();
+    }
+
+    if (Peek() == LEX_CHAR_RIGHT_BRACE) {
+        Next();
+        return true;
+    }
+
+    if (IsDecimalDigit(Peek())) {
+        uint32_t rightValue = 0;
+        while (IsDecimalDigit(Peek())) {
+            uint32_t newValue = rightValue * MULTIPLIER + DigitValue(Next());
+            if (newValue < rightValue) {
+                rightValue = std::numeric_limits<uint32_t>::max();
+                continue;
+            }
+
+            rightValue = newValue;
+        }
+
+        if (Peek() == LEX_CHAR_RIGHT_BRACE) {
+            if (rightValue < leftValue) {
+                ThrowError("Quantifier range out of order");
+            }
+
+            Next();
+            return true;
+        }
+    }
+
+    iter_ = startPos;
+    return false;
+}
+
+bool RegExpParser::ParsePatternCharacter()
+{
+    char32_t cp = Peek();
+    if (IsSyntaxCharacter(cp)) {
+        return false;
+    }
+
+    Next();
+    return true;
+}
+
+static bool IsIdStart(uint32_t cp)
+{
+    auto uchar = static_cast<UChar>(cp);
+    return u_isIDStart(uchar) != 0 || cp == LEX_CHAR_DOLLAR_SIGN || cp == LEX_CHAR_UNDERSCORE;
+}
+
+static bool IsIdCont(uint32_t cp)
+{
+    auto uchar = static_cast<UChar>(cp);
+    return u_isIDPart(uchar) != 0 || cp == LEX_CHAR_DOLLAR_SIGN || cp == LEX_CHAR_ZWNJ || cp == LEX_CHAR_ZWJ;
+}
+
+util::StringView RegExpParser::ParseIdent()
+{
+    char32_t cp = Next();
+    if (cp == LEX_CHAR_BACKSLASH) {
+        if (Next() != LEX_CHAR_LOWERCASE_U) {
+            ThrowError("Invalid group name");
+        }
+
+        if (!Unicode() && Peek() == LEX_CHAR_LEFT_BRACE) {
+            ThrowError("Invalid Unicode escape");
+        }
+
+        cp = ParseUnicodeEscape();
+    }
+
+    if (!IsIdStart(cp)) {
+        ThrowError("Invalid group name");
+    }
+
+    util::UString ident(allocator_);
+    ident.Append(cp);
+
+    while (true) {
+        cp = Next();
+        if (cp == LEX_CHAR_GREATER_THAN) {
+            break;
+        }
+
+        if (cp == LEX_CHAR_BACKSLASH) {
+            if (Next() != LEX_CHAR_LOWERCASE_U) {
+                ThrowError("Invalid group name");
+            }
+
+            if (!Unicode() && Peek() == LEX_CHAR_LEFT_BRACE) {
+                ThrowError("Invalid Unicode escape");
+            }
+
+            cp = ParseUnicodeEscape();
+        }
+
+        if (!IsIdCont(cp)) {
+            ThrowError("Invalid group name");
+        }
+
+        ident.Append(cp);
+    }
+
+    return ident.View();
+}
+
+}  // namespace panda::es2panda::lexer
diff --git a/es2panda/lexer/regexp/regexp.h b/es2panda/lexer/regexp/regexp.h
new file mode 100644
index 0000000000000000000000000000000000000000..513c3405188ab5dcaed74db76a1fedf6fa150b8e
--- /dev/null
+++ b/es2panda/lexer/regexp/regexp.h
@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_REGEXP_H
+#define ES2PANDA_PARSER_CORE_REGEXP_H
+
+#include <util/enumbitops.h>
+#include <util/ustring.h>
+
+#include <unordered_set>
+
+namespace panda::es2panda::lexer {
+
+enum class RegExpFlags {
+    EMPTY = 0,
+    GLOBAL = 1 << 0,
+    IGNORE_CASE = 1 << 1,
+    MULTILINE = 1 << 2,
+    STICKY = 1 << 3,
+    UNICODE = 1 << 4,
+    DOTALL = 1 << 5,
+};
+
+DEFINE_BITOPS(RegExpFlags)
+
+class RegExpError : std::exception {
+public:
+    explicit RegExpError(std::string_view m);
+    std::string message;
+};
+
+struct RegExp {
+    RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags);
+
+    util::StringView patternStr;
+    util::StringView flagsStr;
+    RegExpFlags flags;
+};
+
+class RegExpParser {
+public:
+    explicit RegExpParser(const RegExp &re, ArenaAllocator *allocator);
+    void ParsePattern();
+
+private:
+    void ParseDisjunction();
+    void ParseAlternatives();
+    void ParseAlternative();
+
+    void ParseNonCapturingGroup();
+    void ParseNamedCapturingGroup();
+    void ParseCapturingGroup();
+
+    void ParseAssertion();
+    char32_t ParseClassAtom();
+    void ParseCharacterClass();
+    void ParseAtomEscape();
+
+    uint32_t ParseControlEscape();
+    uint32_t ParseDecimalEscape();
+    uint32_t ParseLegacyOctalEscape();
+    uint32_t ParseHexEscape();
+    uint32_t ParseUnicodeDigits();
+    uint32_t ParseUnicodeEscape();
+
+    void ParseUnicodePropertyEscape();
+    void ParseNamedBackreference();
+
+    void ParseQuantifier();
+    bool ParseBracedQuantifier();
+
+    bool IsSyntaxCharacter(char32_t cp) const;
+    bool ParsePatternCharacter();
+
+    util::StringView ParseIdent();
+
+    bool Unicode() const;
+
+    char32_t Peek() const;
+    char32_t Next();
+    void Advance();
+    bool Eos() const;
+
+    RegExp re_;
+    ArenaAllocator *allocator_ {};
+    util::StringView::Iterator iter_;
+    uint32_t capturingGroupCount_;
+    std::unordered_set<util::StringView> groupNames_;
+};
+
+}  // namespace panda::es2panda::lexer
+
+#endif
diff --git a/es2panda/lexer/scripts/keywords.rb b/es2panda/lexer/scripts/keywords.rb
new file mode 100644
index 0000000000000000000000000000000000000000..d3ae98705f3d2978a730be8d6c4d4e51669d5812
--- /dev/null
+++ b/es2panda/lexer/scripts/keywords.rb
@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'erb'
+require 'ostruct'
+require 'set'
+
+keywords = [
+    # keywords start with 'a'
+    {
+        "abstract" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_ABSTRACT"],
+        "any" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_ANY"],
+        "arguments" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_ARGUMENTS"],
+        "as" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_AS"],
+        "asserts" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_ASSERTS"],
+        "async" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_ASYNC"],
+        "await" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_AWAIT"],
+    },
+
+    # keywords start with 'b'
+    {
+        "bigint" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_BIGINT"],
+        "boolean" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_BOOLEAN"],
+        "break" => ["TokenType::KEYW_BREAK", "TokenType::KEYW_BREAK"],
+    },
+
+    # keywords start with 'c'
+    {
+        "case" => ["TokenType::KEYW_CASE", "TokenType::KEYW_CASE"],
+        "catch" => ["TokenType::KEYW_CATCH", "TokenType::KEYW_CATCH"],
+        "class" => ["TokenType::KEYW_CLASS", "TokenType::KEYW_CLASS"],
+        "const" => ["TokenType::KEYW_CONST", "TokenType::KEYW_CONST"],
+        "continue" => ["TokenType::KEYW_CONTINUE", "TokenType::KEYW_CONTINUE"]
+    },
+
+    # keywords start with 'd'
+    {
+        "debugger" => ["TokenType::KEYW_DEBUGGER", "TokenType::KEYW_DEBUGGER"],
+        "declare" => ["TokenType::KEYW_DECLARE", "TokenType::KEYW_DECLARE"],
+        "default" => ["TokenType::KEYW_DEFAULT", "TokenType::KEYW_DEFAULT"],
+        "delete" => ["TokenType::KEYW_DELETE", "TokenType::KEYW_DELETE"],
+        "do" => ["TokenType::KEYW_DO", "TokenType::KEYW_DO"],
+    },
+
+    # keywords start with 'e'
+    {
+        "else" => ["TokenType::KEYW_ELSE", "TokenType::KEYW_ELSE"],
+        "enum" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_ENUM"],
+        "eval" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_EVAL"],
+        "export" => ["TokenType::KEYW_EXPORT", "TokenType::KEYW_EXPORT"],
+        "extends" => ["TokenType::KEYW_EXTENDS", "TokenType::KEYW_EXTENDS"],
+    },
+
+    # keywords start with 'f'
+    {
+        "false" => ["TokenType::LITERAL_FALSE", "TokenType::LITERAL_FALSE"],
+        "finally" => ["TokenType::KEYW_FINALLY", "TokenType::KEYW_FINALLY"],
+        "for" => ["TokenType::KEYW_FOR", "TokenType::KEYW_FOR"],
+        "from" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_FROM"],
+        "function" => ["TokenType::KEYW_FUNCTION", "TokenType::KEYW_FUNCTION"],
+    },
+
+    # keywords start with 'g'
+    {
+        "get" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_GET"],
+        "global" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_GLOBAL"],
+    },
+
+    # keywords start with 'i'
+    {
+        "if" => ["TokenType::KEYW_IF", "TokenType::KEYW_IF"],
+        "implements" => ["TokenType::KEYW_IMPLEMENTS", "TokenType::KEYW_IMPLEMENTS"],
+        "import" => ["TokenType::KEYW_IMPORT", "TokenType::KEYW_IMPORT"],
+        "in" => ["TokenType::KEYW_IN", "TokenType::KEYW_IN"],
+        "infer" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_INFER"],
+        "instanceof" => ["TokenType::KEYW_INSTANCEOF", "TokenType::KEYW_INSTANCEOF"],
+        "interface" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_INTERFACE"],
+        "is" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_IS"],
+    },
+
+    # keywords start with 'k'
+    {
+        "keyof" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_KEYOF"],
+    },
+
+    # keywords start with 'l'
+    {
+        "let" => ["TokenType::KEYW_LET", "TokenType::KEYW_LET"],
+    },
+
+    # keywords start with 'm'
+    {
+        "meta" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_META"],
+        "module" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_MODULE"],
+        "namespace" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_NAMESPACE"],
+    },
+
+    # keywords start with 'n'
+    {
+        "never" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_NEVER"],
+        "new" => ["TokenType::KEYW_NEW", "TokenType::KEYW_NEW"],
+        "null" => ["TokenType::LITERAL_NULL", "TokenType::LITERAL_NULL"],
+        "number" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_NUMBER"],
+    },
+
+    # keywords start with 'o'
+    {
+        "object" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_OBJECT"],
+        "of" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_OF"],
+    },
+
+    # keywords start with 'p'
+    {
+        "package" => ["TokenType::KEYW_PACKAGE", "TokenType::KEYW_PACKAGE"],
+        "private" => ["TokenType::KEYW_PRIVATE", "TokenType::KEYW_PRIVATE"],
+        "protected" => ["TokenType::KEYW_PROTECTED", "TokenType::KEYW_PROTECTED"],
+        "public" => ["TokenType::KEYW_PUBLIC", "TokenType::KEYW_PUBLIC"],
+    },
+
+    # keywords start with 'r'
+    {
+        "readonly" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_READONLY"],
+        "return" => ["TokenType::KEYW_RETURN", "TokenType::KEYW_RETURN"],
+        "require" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_REQUIRE"],
+    },
+
+    # keywords start with 's'
+    {
+        "set" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_SET"],
+        "static" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_STATIC"],
+        "string" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_STRING"],
+        "super" => ["TokenType::KEYW_SUPER", "TokenType::KEYW_SUPER"],
+        "switch" => ["TokenType::KEYW_SWITCH", "TokenType::KEYW_SWITCH"],
+    },
+
+    # keywords start with 't'
+    {
+        "this" => ["TokenType::KEYW_THIS", "TokenType::KEYW_THIS"],
+        "throw" => ["TokenType::KEYW_THROW", "TokenType::KEYW_THROW"],
+        "true" => ["TokenType::LITERAL_TRUE", "TokenType::LITERAL_TRUE"],
+        "try" => ["TokenType::KEYW_TRY", "TokenType::KEYW_TRY"],
+        "type" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_TYPE"],
+        "typeof" => ["TokenType::KEYW_TYPEOF", "TokenType::KEYW_TYPEOF"],
+    },
+
+    # keywords start with 'u'
+    {
+        "undefined" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_UNDEFINED"],
+        "unknown" => ["TokenType::LITERAL_IDENT", "TokenType::KEYW_UNKNOWN"],
+    },
+
+    # keywords start with 'v'
+    {
+        "var" => ["TokenType::KEYW_VAR", "TokenType::KEYW_VAR"],
+        "void" => ["TokenType::KEYW_VOID", "TokenType::KEYW_VOID"],
+    },
+
+    # keywords start with 'w'
+    {
+        "while" => ["TokenType::KEYW_WHILE", "TokenType::KEYW_WHILE"],
+        "with" => ["TokenType::KEYW_WITH", "TokenType::KEYW_WITH"],
+    },
+
+    # keywords start with 'y'
+    {
+        "yield" => ["TokenType::KEYW_YIELD", "TokenType::KEYW_YIELD"],
+    },
+]
+
+def collect_functions(functions, keys)
+    offset = 0
+
+    while true
+        has_more = false
+
+        keys.each do |key|
+            if key.length < offset + 1
+                next
+            end
+
+            has_more = true
+            func_name = key[0..offset];
+
+            if functions.has_key?(func_name)
+                functions[func_name].add(key[offset + 1])
+            else
+                functions[func_name] = Set[key[offset + 1]]
+            end
+        end
+
+        if has_more
+            offset += 1
+            next
+        end
+
+        break
+    end
+end
+
+def generate(keywords, template_file, output_file)   
+    functions = {}
+    keywords.each do |group|
+        collect_functions(functions, group.keys)
+    end
+
+    template = File.read(template_file)
+    t = ERB.new(template, nil, '%-')
+    t.filename = OpenStruct.new.template
+    res = t.result(binding)
+
+    File.open(output_file, "w") do |file|
+        file.write(res)
+    end
+end
+
+abort "Failed: input file required!" if ARGV.size < 2
+
+generate(keywords, ARGV[0], ARGV[1])
diff --git a/es2panda/lexer/templates/keywords.h.erb b/es2panda/lexer/templates/keywords.h.erb
new file mode 100644
index 0000000000000000000000000000000000000000..fa2851a2c88289d22c803f556da360a2e926c23e
--- /dev/null
+++ b/es2panda/lexer/templates/keywords.h.erb
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Autogenerated file -- DO NOT EDIT!
+
+#include <gen/keywordsMap.h>
+#include <lexer/keywordsUtil.h>
+#include <lexer/token/letters.h>
+#include <macros.h>
+#include <utils/span.h>
+
+namespace panda::es2panda::lexer {
+
+class Keywords {
+public:
+    explicit Keywords(Lexer* lexer, lexer::LexerNextTokenFlags flags) : util_(KeywordsUtil(lexer, flags)) {}
+    NO_COPY_SEMANTIC(Keywords);
+    NO_MOVE_SEMANTIC(Keywords);
+    ~Keywords() = default;
+
+    KeywordsUtil &Util() {
+        return util_;
+    }
+
+    // NOLINTNEXTLINE(readability-function-size)
+    static void SetKeyword(KeywordsUtil *util, const KeywordString& kws) {
+        switch(kws.keywordType) {
+% keywords.each do |group|
+%   group.each do |key, kw|
+        case <%= kw[1] %>: {
+            return util->SetKeyword<<%= kw[1] %>>(kws.str, kws.tokenType);
+        }
+%   end
+% end
+        default: {
+            break;
+        }
+        }
+    }
+
+% functions.each do |key, prefixes|
+    inline void Scan<%= key.upcase %>()
+    {
+        switch(util_.Iterator().Peek()) {
+% prefixes.select{|p| !p.nil? }.each do |prefix|
+        case LEX_CHAR_LOWERCASE_<%=prefix.upcase%>: /* '<%=prefix%>' */ {
+            util_.Iterator().Forward(1);
+            Scan<%= key.upcase %><%= prefix.upcase %>();
+            return;
+        }
+% end
+% if prefixes.include?(nil)
+% kw = keywords.find{ |x| x.has_key?(key)}[key]
+        default: {
+            if (!KeywordsUtil::IsIdentifierPart(util_.Iterator().PeekCp())) {
+                util_.SetKeyword<<%=kw[1]%>>("<%=key%>", <%=kw[0]%>);
+                return;
+            }
+            break;
+        }
+        }
+% else
+        default: {
+            break;
+        }
+        }
+% end
+        util_.ScanIdContinueMaybeKeyword(Span<const KeywordString>(KeywordsMap::KEYWORDS_<%= key[0].upcase %>));
+    }
+
+% end
+
+private:
+    KeywordsUtil util_;
+};
+
+} // namespace panda::es2panda::lexer
diff --git a/es2panda/lexer/templates/keywordsMap.h.erb b/es2panda/lexer/templates/keywordsMap.h.erb
new file mode 100644
index 0000000000000000000000000000000000000000..f36309537e8573861ff8b189fbcfc18b4c3e0dc8
--- /dev/null
+++ b/es2panda/lexer/templates/keywordsMap.h.erb
@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Autogenerated file -- DO NOT EDIT!
+
+#include <lexer/keywordString.h>
+#include <utils/span.h>
+
+namespace panda::es2panda::lexer {
+
+class KeywordsMap {
+public:
+    KeywordsMap() = delete;
+
+    static Span<const KeywordString> Map(char32_t cp) {
+        switch(cp) {
+% keywords.each do |group|
+        case LEX_CHAR_LOWERCASE_<%= group.keys[0][0].upcase %>: {
+            return Span<const KeywordString>(KEYWORDS_<%= group.keys[0][0].upcase %>);
+        }
+% end
+        default: {
+            return Span<const KeywordString>();
+        }
+        }
+    }
+
+% keywords.each do |group|
+
+    static constexpr std::array<const KeywordString, <%= group.size %>> KEYWORDS_<%= group.keys[0][0].upcase %> = {{
+%   group.each do |key, kw|
+        {"<%= key%>", <%= kw[0] %>, <%= kw[1] %>},
+%   end
+    }};
+% end
+};
+
+} // namespace panda::es2panda::lexer
diff --git a/es2panda/lexer/token/letters.h b/es2panda/lexer/token/letters.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ca37714066984d42954c382804b8eea8a0d5625
--- /dev/null
+++ b/es2panda/lexer/token/letters.h
@@ -0,0 +1,158 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_LETTERS_H
+#define ES2PANDA_PARSER_CORE_LETTERS_H
+
+namespace panda::es2panda::lexer {
+
+#define LEX_ASCII_MAX_BITS 128
+
+#define LEX_CHAR_NULL 0x00 /* \0 */
+
+// Line Terminators
+#define LEX_CHAR_LF 0x0A   /* line feed */
+#define LEX_CHAR_CR 0x0D   /* carriage return */
+#define LEX_CHAR_LS 0x2028 /* line separator */
+#define LEX_CHAR_PS 0x2029 /* paragraph separator */
+
+#define LEX_CHAR_LOWERCASE_A 0x61 /* a */
+#define LEX_CHAR_LOWERCASE_B 0x62 /* b */
+#define LEX_CHAR_LOWERCASE_C 0x63 /* c */
+#define LEX_CHAR_LOWERCASE_D 0x64 /* d */
+#define LEX_CHAR_LOWERCASE_E 0X65 /* e */
+#define LEX_CHAR_LOWERCASE_F 0X66 /* f */
+#define LEX_CHAR_LOWERCASE_G 0X67 /* g */
+#define LEX_CHAR_LOWERCASE_H 0X68 /* h */
+#define LEX_CHAR_LOWERCASE_I 0X69 /* i */
+#define LEX_CHAR_LOWERCASE_J 0X6A /* j */
+#define LEX_CHAR_LOWERCASE_K 0X6B /* k */
+#define LEX_CHAR_LOWERCASE_L 0X6C /* l */
+#define LEX_CHAR_LOWERCASE_M 0X6D /* m */
+#define LEX_CHAR_LOWERCASE_N 0X6E /* n */
+#define LEX_CHAR_LOWERCASE_O 0X6F /* o */
+#define LEX_CHAR_LOWERCASE_P 0x70 /* p */
+#define LEX_CHAR_LOWERCASE_Q 0x71 /* q */
+#define LEX_CHAR_LOWERCASE_R 0x72 /* r */
+#define LEX_CHAR_LOWERCASE_S 0x73 /* s */
+#define LEX_CHAR_LOWERCASE_T 0x74 /* t */
+#define LEX_CHAR_LOWERCASE_U 0x75 /* u */
+#define LEX_CHAR_LOWERCASE_V 0x76 /* v */
+#define LEX_CHAR_LOWERCASE_W 0x77 /* W */
+#define LEX_CHAR_LOWERCASE_X 0x78 /* x */
+#define LEX_CHAR_LOWERCASE_Y 0x79 /* y */
+#define LEX_CHAR_LOWERCASE_Z 0x7A /* z */
+
+#define LEX_CHAR_UPPERCASE_A 0X41 /* A */
+#define LEX_CHAR_UPPERCASE_B 0X42 /* B */
+#define LEX_CHAR_UPPERCASE_C 0X43 /* C */
+#define LEX_CHAR_UPPERCASE_D 0X44 /* B */
+#define LEX_CHAR_UPPERCASE_E 0X45 /* E */
+#define LEX_CHAR_UPPERCASE_F 0X46 /* F */
+#define LEX_CHAR_UPPERCASE_G 0X47 /* G */
+#define LEX_CHAR_UPPERCASE_H 0X48 /* H */
+#define LEX_CHAR_UPPERCASE_I 0X49 /* I */
+#define LEX_CHAR_UPPERCASE_J 0X4A /* J */
+#define LEX_CHAR_UPPERCASE_K 0X4B /* K */
+#define LEX_CHAR_UPPERCASE_L 0X4C /* L */
+#define LEX_CHAR_UPPERCASE_M 0X4D /* M */
+#define LEX_CHAR_UPPERCASE_N 0X4E /* N */
+#define LEX_CHAR_UPPERCASE_O 0X4F /* O */
+#define LEX_CHAR_UPPERCASE_P 0X50 /* P */
+#define LEX_CHAR_UPPERCASE_Q 0X51 /* Q */
+#define LEX_CHAR_UPPERCASE_R 0X52 /* R */
+#define LEX_CHAR_UPPERCASE_S 0X53 /* S */
+#define LEX_CHAR_UPPERCASE_T 0X54 /* T */
+#define LEX_CHAR_UPPERCASE_U 0X55 /* U */
+#define LEX_CHAR_UPPERCASE_V 0X56 /* V */
+#define LEX_CHAR_UPPERCASE_W 0X57 /* W */
+#define LEX_CHAR_UPPERCASE_X 0x58 /* X */
+#define LEX_CHAR_UPPERCASE_Y 0x59 /* Y */
+#define LEX_CHAR_UPPERCASE_Z 0x5A /* X */
+
+#define LEX_CHAR_BS 0x08           /* backspace */
+#define LEX_CHAR_TAB 0x09          /* character tabulation */
+#define LEX_CHAR_VT 0x0B           /* liner tabulation */
+#define LEX_CHAR_FF 0x0C           /* form feed */
+#define LEX_CHAR_SP 0x20           /* space */
+#define LEX_CHAR_NBSP 0xA0         /* no-break space */
+#define LEX_CHAR_ZWNBSP 0xFEFF     /* zero width no-break space */
+#define LEX_CHAR_MVS 0x180e        /* MONGOLIAN VOWEL SEPARATOR (U+180E) */
+#define LEX_CHAR_DOUBLE_QUOTE 0x22 /* " */
+#define LEX_CHAR_DOLLAR_SIGN 0x24  /* $ */
+#define LEX_CHAR_SINGLE_QUOTE 0x27 /* ' */
+#define LEX_CHAR_DOT 0x2E          /* . */
+
+#define LEX_CHAR_0 0x30 /* 0 */
+#define LEX_CHAR_1 0x31 /* 1 */
+#define LEX_CHAR_2 0x32 /* 2 */
+#define LEX_CHAR_3 0x33 /* 3 */
+#define LEX_CHAR_4 0x34 /* 4 */
+#define LEX_CHAR_5 0x35 /* 5 */
+#define LEX_CHAR_6 0x36 /* 6 */
+#define LEX_CHAR_7 0x37 /* 7 */
+#define LEX_CHAR_8 0x38 /* 8 */
+#define LEX_CHAR_9 0x39 /* 9 */
+
+#define LEX_CHAR_BACKSLASH 0X5c  /* \\ */
+#define LEX_CHAR_UNDERSCORE 0x5F /* _ */
+
+// Punctuator characters
+#define LEX_CHAR_EXCLAMATION 0x21  /* exclamation mark */
+#define LEX_CHAR_PERCENT 0x25      /* percent sign */
+#define LEX_CHAR_AMPERSAND 0x26    /* ampersand */
+#define LEX_CHAR_LEFT_PAREN 0x28   /* left parenthesis */
+#define LEX_CHAR_RIGHT_PAREN 0x29  /* right parenthesis */
+#define LEX_CHAR_ASTERISK 0x2A     /* asterisk */
+#define LEX_CHAR_PLUS 0x2B         /* plus sign */
+#define LEX_CHAR_COMMA 0x2C        /* comma */
+#define LEX_CHAR_PLUS 0x2B         /* plus */
+#define LEX_CHAR_MINUS 0x2D        /* hyphen-minus */
+#define LEX_CHAR_DOT 0x2E          /* dot */
+#define LEX_CHAR_SLASH 0x2F        /* solidus */
+#define LEX_CHAR_COLON 0x3A        /* colon */
+#define LEX_CHAR_SEMICOLON 0x3B    /* semicolon */
+#define LEX_CHAR_LESS_THAN 0x3C    /* less-than sign */
+#define LEX_CHAR_EQUALS 0x3D       /* equals sign */
+#define LEX_CHAR_GREATER_THAN 0x3E /* greater-than sign */
+#define LEX_CHAR_QUESTION 0x3F     /* question mark */
+#define LEX_CHAR_LEFT_SQUARE 0x5B  /* left square bracket */
+#define LEX_CHAR_RIGHT_SQUARE 0x5D /* right square bracket */
+#define LEX_CHAR_CIRCUMFLEX 0x5E   /* circumflex accent */
+#define LEX_CHAR_LEFT_BRACE 0x7B   /* left curly bracket */
+#define LEX_CHAR_VLINE 0x7C        /* vertical line */
+#define LEX_CHAR_RIGHT_BRACE 0x7D  /* right curly bracket */
+#define LEX_CHAR_TILDE 0x7E        /* tilde */
+#define LEX_CHAR_BACK_TICK 0x60    /* back tick */
+#define LEX_CHAR_HASH_MARK 0x23    /* hash mark */
+#define LEX_CHAR_AT 0x40           /* at */
+
+#define LEX_CHAR_ZWNJ 0x200C /* zero width non-joiner */
+#define LEX_CHAR_ZWJ 0x200D  /* zero width joiner */
+
+#define LEX_VERTICAL_TILDE 0x2E2F /* vertical tilde */
+
+#define LEX_TO_ASCII_LOWERCASE(character) ((character) | LEX_CHAR_SP)
+
+#define LEX_UTF8_2_BYTE_CODE_POINT_MIN (0x80)
+#define LEX_UTF8_EXTRA_BYTE_MASK (0xC0)
+
+#define LEX_CHAR_EOS 0xFFFF
+#define UNICODE_CODE_POINT_MAX 0x10FFFF
+#define UNICODE_INVALID_CP UINT32_MAX
+
+}  // namespace panda::es2panda::lexer
+
+#endif
diff --git a/es2panda/lexer/token/sourceLocation.cpp b/es2panda/lexer/token/sourceLocation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9d1e4ea60474c0cdcdee2a703c35ae8e5bab8698
--- /dev/null
+++ b/es2panda/lexer/token/sourceLocation.cpp
@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "sourceLocation.h"
+
+#include <lexer/token/letters.h>
+
+#include <cstdint>
+
+namespace panda::es2panda::lexer {
+
+void OffsetEntry::AddCol(size_t offset)
+{
+    size_t diff = offset - offset_;
+    offset_ = offset;
+
+    if (ranges.empty()) {
+        ranges.emplace_back(Range {diff});
+        return;
+    }
+
+    auto &range = ranges.back();
+
+    if (diff == range.byteSize) {
+        range.cnt++;
+    } else {
+        ranges.emplace_back(Range {diff});
+    }
+}
+
+LineIndex::LineIndex(const util::StringView &source) noexcept
+{
+    auto iter = util::StringView::Iterator(source);
+    entrys_.emplace_back(0);
+
+    while (true) {
+        switch (iter.Next()) {
+            case util::StringView::Iterator::INVALID_CP: {
+                return;
+            }
+            case LEX_CHAR_CR: {
+                if (iter.HasNext() && iter.Peek() == LEX_CHAR_LF) {
+                    iter.Forward(1);
+                }
+
+                [[fallthrough]];
+            }
+            case LEX_CHAR_LF:
+            case LEX_CHAR_PS:
+            case LEX_CHAR_LS: {
+                entrys_.emplace_back(iter.Index());
+                break;
+            }
+            default: {
+                entrys_.back().AddCol(iter.Index());
+            }
+        }
+    }
+}
+
+SourceLocation LineIndex::GetLocation(SourcePosition pos) noexcept
+{
+    size_t line = pos.line;
+
+    size_t col = 0;
+    const auto &entry = entrys_[pos.line];
+    size_t diff = pos.index - entry.lineStart;
+
+    for (const auto &range : entry.ranges) {
+        if (diff < range.cnt) {
+            col += diff;
+            break;
+        }
+
+        diff -= range.cnt * range.byteSize;
+        col += range.cnt;
+    }
+
+    return SourceLocation(line + 1, col + 1);
+}
+
+}  // namespace panda::es2panda::lexer
diff --git a/es2panda/lexer/token/sourceLocation.h b/es2panda/lexer/token/sourceLocation.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f0fa27a2c521d90aa35eac03f8d8f505804a2c4
--- /dev/null
+++ b/es2panda/lexer/token/sourceLocation.h
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_LEXER_TOKEN_SOURCE_LOCATION_H
+#define ES2PANDA_LEXER_TOKEN_SOURCE_LOCATION_H
+
+#include <macros.h>
+#include <util/ustring.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace panda::es2panda::lexer {
+
+class SourcePosition {
+public:
+    explicit SourcePosition() noexcept = default;
+    explicit SourcePosition(size_t i, size_t l) noexcept : index(i), line(l) {}
+    DEFAULT_COPY_SEMANTIC(SourcePosition);
+    DEFAULT_MOVE_SEMANTIC(SourcePosition);
+    ~SourcePosition() = default;
+
+    size_t index {};
+    size_t line {};
+};
+
+class SourceRange {
+public:
+    explicit SourceRange() noexcept = default;
+    SourceRange(SourcePosition s, SourcePosition e) noexcept : start(s), end(e) {}
+    DEFAULT_COPY_SEMANTIC(SourceRange);
+    DEFAULT_MOVE_SEMANTIC(SourceRange);
+    ~SourceRange() = default;
+
+    SourcePosition start {};
+    SourcePosition end {};
+};
+
+class SourceLocation {
+public:
+    explicit SourceLocation() noexcept = default;
+    explicit SourceLocation(size_t l, size_t c) noexcept : line(l), col(c) {}
+    DEFAULT_COPY_SEMANTIC(SourceLocation);
+    DEFAULT_MOVE_SEMANTIC(SourceLocation);
+    ~SourceLocation() = default;
+
+    size_t line {};
+    size_t col {};
+};
+
+class Range {
+public:
+    explicit Range(size_t bS) noexcept : byteSize(bS) {}
+
+    DEFAULT_COPY_SEMANTIC(Range);
+    DEFAULT_MOVE_SEMANTIC(Range);
+    ~Range() = default;
+
+    size_t byteSize {};
+    size_t cnt {1};
+};
+
+class OffsetEntry {
+public:
+    explicit OffsetEntry(size_t l) : lineStart(l), offset_(l) {};
+
+    DEFAULT_COPY_SEMANTIC(OffsetEntry);
+    DEFAULT_MOVE_SEMANTIC(OffsetEntry);
+    ~OffsetEntry() = default;
+
+    void AddCol(size_t offset);
+
+    std::vector<Range> ranges {};
+    size_t lineStart {};
+
+private:
+    size_t offset_ {};
+};
+
+class LineIndex {
+public:
+    explicit LineIndex(const util::StringView &source) noexcept;
+    NO_COPY_SEMANTIC(LineIndex);
+    NO_MOVE_SEMANTIC(LineIndex);
+    ~LineIndex() = default;
+
+    SourceLocation GetLocation(SourcePosition pos) noexcept;
+
+private:
+    std::vector<OffsetEntry> entrys_;
+};
+
+}  // namespace panda::es2panda::lexer
+
+#endif
diff --git a/es2panda/lexer/token/token.cpp b/es2panda/lexer/token/token.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..12521b9dada193b33275e445a53d6700fe3a9e84
--- /dev/null
+++ b/es2panda/lexer/token/token.cpp
@@ -0,0 +1,244 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "token.h"
+
+namespace panda::es2panda::lexer {
+
+bool Token::IsAccessability() const
+{
+    return (type_ == TokenType::LITERAL_IDENT &&
+            (keywordType_ == TokenType::KEYW_PUBLIC || keywordType_ == TokenType::KEYW_PROTECTED ||
+             keywordType_ == TokenType::KEYW_PRIVATE) &&
+            !(flags_ & TokenFlags::HAS_ESCAPE));
+}
+
+bool Token::IsAsyncModifier() const
+{
+    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_ASYNC &&
+            !(flags_ & TokenFlags::HAS_ESCAPE));
+}
+
+bool Token::IsStaticModifier() const
+{
+    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_STATIC &&
+            !(flags_ & TokenFlags::HAS_ESCAPE));
+}
+
+bool Token::IsDeclareModifier() const
+{
+    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_DECLARE &&
+            !(flags_ & TokenFlags::HAS_ESCAPE));
+}
+
+bool Token::IsReadonlyModifier() const
+{
+    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_READONLY &&
+            !(flags_ & TokenFlags::HAS_ESCAPE));
+}
+
+bool Token::IsUpdate() const
+{
+    return (type_ == TokenType::PUNCTUATOR_MINUS_MINUS || type_ == TokenType::PUNCTUATOR_PLUS_PLUS);
+}
+
+bool Token::IsUnary() const
+{
+    return (type_ == TokenType::PUNCTUATOR_MINUS || type_ == TokenType::PUNCTUATOR_PLUS ||
+            type_ == TokenType::PUNCTUATOR_TILDE || type_ == TokenType::PUNCTUATOR_EXCLAMATION_MARK ||
+            type_ == TokenType::PUNCTUATOR_PLUS_PLUS || type_ == TokenType::PUNCTUATOR_MINUS_MINUS ||
+            type_ == TokenType::KEYW_TYPEOF || type_ == TokenType::KEYW_VOID || type_ == TokenType::KEYW_DELETE ||
+            type_ == TokenType::KEYW_AWAIT);
+}
+
+bool Token::IsPropNameLiteral() const
+{
+    return (type_ == TokenType::LITERAL_STRING || type_ == TokenType::LITERAL_NUMBER ||
+            type_ == TokenType::LITERAL_TRUE || type_ == TokenType::LITERAL_FALSE);
+}
+
+bool Token::IsKeyword() const
+{
+    return (type_ >= TokenType::FIRST_KEYW);
+}
+
+bool Token::IsReservedTypeName() const
+{
+    switch (keywordType_) {
+        case TokenType::KEYW_ANY:
+        case TokenType::KEYW_UNKNOWN:
+        case TokenType::KEYW_NEVER:
+        case TokenType::KEYW_NUMBER:
+        case TokenType::KEYW_BIGINT:
+        case TokenType::KEYW_BOOLEAN:
+        case TokenType::KEYW_STRING:
+        case TokenType::KEYW_VOID:
+        case TokenType::KEYW_OBJECT:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool Token::IsBinaryToken(TokenType type)
+{
+    return (type >= TokenType::PUNCTUATOR_NULLISH_COALESCING && type <= TokenType::PUNCTUATOR_EXPONENTIATION);
+}
+
+bool Token::IsBinaryLvalueToken(TokenType type)
+{
+    return (type >= TokenType::PUNCTUATOR_SUBSTITUTION && type <= TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL);
+}
+
+bool Token::IsUpdateToken(TokenType type)
+{
+    return (type == TokenType::PUNCTUATOR_MINUS_MINUS || type == TokenType::PUNCTUATOR_PLUS_PLUS);
+}
+
+bool Token::IsPunctuatorToken(TokenType type)
+{
+    return (type >= TokenType::PUNCTUATOR_NULLISH_COALESCING && type <= TokenType::PUNCTUATOR_ARROW);
+}
+
+bool Token::IsTsParamToken(TokenType type)
+{
+    return (type == TokenType::PUNCTUATOR_COLON || type == TokenType::PUNCTUATOR_QUESTION_MARK);
+}
+
+const char *TokenToString(TokenType type)
+{
+    switch (type) {
+        case TokenType::PUNCTUATOR_BITWISE_AND:
+            return "&";
+        case TokenType::PUNCTUATOR_BITWISE_OR:
+            return "|";
+        case TokenType::PUNCTUATOR_MULTIPLY:
+            return "*";
+        case TokenType::PUNCTUATOR_DIVIDE:
+            return "/";
+        case TokenType::PUNCTUATOR_MINUS:
+            return "-";
+        case TokenType::PUNCTUATOR_EXCLAMATION_MARK:
+            return "!";
+        case TokenType::PUNCTUATOR_TILDE:
+            return "~";
+        case TokenType::PUNCTUATOR_MINUS_MINUS:
+            return "--";
+        case TokenType::PUNCTUATOR_LEFT_SHIFT:
+            return "<<";
+        case TokenType::PUNCTUATOR_RIGHT_SHIFT:
+            return ">>";
+        case TokenType::PUNCTUATOR_LESS_THAN_EQUAL:
+            return "<=";
+        case TokenType::PUNCTUATOR_GREATER_THAN_EQUAL:
+            return ">=";
+        case TokenType::PUNCTUATOR_MOD:
+            return "%";
+        case TokenType::PUNCTUATOR_BITWISE_XOR:
+            return "^";
+        case TokenType::PUNCTUATOR_EXPONENTIATION:
+            return "**";
+        case TokenType::PUNCTUATOR_MULTIPLY_EQUAL:
+            return "*=";
+        case TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL:
+            return "**=";
+        case TokenType::PUNCTUATOR_DIVIDE_EQUAL:
+            return "/=";
+        case TokenType::PUNCTUATOR_MOD_EQUAL:
+            return "%=";
+        case TokenType::PUNCTUATOR_MINUS_EQUAL:
+            return "-=";
+        case TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL:
+            return "<<=";
+        case TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL:
+            return ">>=";
+        case TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT:
+            return ">>>";
+        case TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL:
+            return ">>>=";
+        case TokenType::PUNCTUATOR_BITWISE_AND_EQUAL:
+            return "&=";
+        case TokenType::PUNCTUATOR_BITWISE_OR_EQUAL:
+            return "|=";
+        case TokenType::PUNCTUATOR_LOGICAL_AND_EQUAL:
+            return "&&=";
+        case TokenType::PUNCTUATOR_NULLISH_COALESCING:
+            return "??";
+        case TokenType::PUNCTUATOR_LOGICAL_OR_EQUAL:
+            return "||=";
+        case TokenType::PUNCTUATOR_LOGICAL_NULLISH_EQUAL:
+            return "\?\?=";
+        case TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL:
+            return "^=";
+        case TokenType::PUNCTUATOR_PLUS:
+            return "+";
+        case TokenType::PUNCTUATOR_PLUS_PLUS:
+            return "++";
+        case TokenType::PUNCTUATOR_PLUS_EQUAL:
+            return "+=";
+        case TokenType::PUNCTUATOR_LESS_THAN:
+            return "<";
+        case TokenType::PUNCTUATOR_GREATER_THAN:
+            return ">";
+        case TokenType::PUNCTUATOR_EQUAL:
+            return "==";
+        case TokenType::PUNCTUATOR_NOT_EQUAL:
+            return "!=";
+        case TokenType::PUNCTUATOR_STRICT_EQUAL:
+            return "===";
+        case TokenType::PUNCTUATOR_NOT_STRICT_EQUAL:
+            return "!==";
+        case TokenType::KEYW_INSTANCEOF:
+            return "instanceof";
+        case TokenType::KEYW_IN:
+            return "in";
+        case TokenType::PUNCTUATOR_LOGICAL_AND:
+            return "&&";
+        case TokenType::PUNCTUATOR_LOGICAL_OR:
+            return "||";
+        case TokenType::PUNCTUATOR_SUBSTITUTION:
+            return "=";
+        case TokenType::PUNCTUATOR_QUESTION_MARK:
+            return "?";
+        case TokenType::PUNCTUATOR_AT:
+            return "@";
+        case TokenType::KEYW_ANY:
+            return "any";
+        case TokenType::KEYW_UNKNOWN:
+            return "unknown";
+        case TokenType::KEYW_NEVER:
+            return "never";
+        case TokenType::KEYW_NUMBER:
+            return "number";
+        case TokenType::KEYW_BIGINT:
+            return "bigint";
+        case TokenType::KEYW_BOOLEAN:
+            return "boolean";
+        case TokenType::KEYW_STRING:
+            return "string";
+        case TokenType::KEYW_VOID:
+            return "void";
+        case TokenType::KEYW_OBJECT:
+            return "object";
+        case TokenType::KEYW_TYPEOF:
+            return "typeof";
+        case TokenType::KEYW_DELETE:
+            return "delete";
+        default:
+            UNREACHABLE();
+    }
+}
+
+}  // namespace panda::es2panda::lexer
diff --git a/es2panda/lexer/token/token.h b/es2panda/lexer/token/token.h
new file mode 100644
index 0000000000000000000000000000000000000000..46a87d432cc1ff7cf96671e75e9391c196b298ae
--- /dev/null
+++ b/es2panda/lexer/token/token.h
@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_TOKEN_H
+#define ES2PANDA_PARSER_CORE_TOKEN_H
+
+#include <lexer/token/sourceLocation.h>
+#include <lexer/token/tokenType.h>
+#include <macros.h>
+#include <util/enumbitops.h>
+#include <util/ustring.h>
+
+namespace panda::es2panda::lexer {
+
+enum class TokenFlags {
+    NONE,
+    NEW_LINE = (1 << 0),
+    HAS_ESCAPE = (1 << 2),
+    NUMBER_BIGINT = (1 << 3),
+    NUMBER_HAS_UNDERSCORE = (1 << 4),
+};
+
+DEFINE_BITOPS(TokenFlags)
+
+class Token {
+public:
+    Token() = default;
+    DEFAULT_COPY_SEMANTIC(Token);
+    DEFAULT_MOVE_SEMANTIC(Token);
+    ~Token() = default;
+
+    friend class Lexer;
+
+    TokenType Type() const
+    {
+        return type_;
+    }
+
+    TokenFlags Flags() const
+    {
+        return flags_;
+    }
+
+    void SetTokenType(TokenType type)
+    {
+        type_ = type;
+    }
+
+    TokenType KeywordType() const
+    {
+        return keywordType_;
+    }
+
+    const SourcePosition &Start() const
+    {
+        return loc_.start;
+    }
+
+    const SourcePosition &End() const
+    {
+        return loc_.end;
+    }
+
+    const SourceRange &Loc() const
+    {
+        return loc_;
+    }
+
+    const util::StringView &Ident() const
+    {
+        return src_;
+    }
+
+    const util::StringView &BigInt() const
+    {
+        ASSERT(type_ == TokenType::LITERAL_NUMBER && (flags_ & TokenFlags::NUMBER_BIGINT));
+        return src_;
+    }
+
+    double Number() const
+    {
+        ASSERT(type_ == TokenType::LITERAL_NUMBER && !(flags_ & TokenFlags::NUMBER_BIGINT));
+        return number_;
+    }
+
+    const util::StringView &String() const
+    {
+        ASSERT(type_ == TokenType::LITERAL_STRING || type_ == TokenType::LITERAL_NUMBER);
+        return src_;
+    }
+
+    bool NewLine() const
+    {
+        return flags_ & TokenFlags::NEW_LINE;
+    }
+
+    bool IsAccessability() const;
+    bool IsAsyncModifier() const;
+    bool IsStaticModifier() const;
+    bool IsDeclareModifier() const;
+    bool IsReadonlyModifier() const;
+    bool IsUpdate() const;
+    bool IsUnary() const;
+    bool IsPropNameLiteral() const;
+    bool IsKeyword() const;
+    bool IsReservedTypeName() const;
+
+    static bool IsBinaryToken(TokenType type);
+    static bool IsBinaryLvalueToken(TokenType type);
+    static bool IsUpdateToken(TokenType type);
+    static bool IsPunctuatorToken(TokenType type);
+    static bool IsTsParamToken(TokenType type);
+
+private:
+    friend class KeywordsUtil;
+    TokenType type_ {TokenType::EOS};
+    TokenType keywordType_ {TokenType::EOS};
+    TokenFlags flags_ {TokenFlags::NONE};
+    SourceRange loc_ {};
+    double number_ {};
+    util::StringView src_ {};
+};
+
+}  // namespace panda::es2panda::lexer
+
+#endif /* TOKEN_H */
diff --git a/es2panda/lexer/token/tokenType.h b/es2panda/lexer/token/tokenType.h
new file mode 100644
index 0000000000000000000000000000000000000000..48f53a5099f3baa9fd044b41bcbbb764b60d9c7d
--- /dev/null
+++ b/es2panda/lexer/token/tokenType.h
@@ -0,0 +1,186 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_TOKEN_TYPE_H
+#define ES2PANDA_PARSER_INCLUDE_TOKEN_TYPE_H
+
+namespace panda::es2panda::lexer {
+
+enum class TokenType {
+    EOS,
+
+    LITERAL_IDENT,
+    LITERAL_STRING,
+    LITERAL_NUMBER,
+    LITERAL_REGEXP,
+    LITERAL_TRUE,
+    LITERAL_FALSE,
+    LITERAL_NULL,
+
+    // Keep this order
+    PUNCTUATOR_NULLISH_COALESCING,
+    PUNCTUATOR_LOGICAL_OR,
+    PUNCTUATOR_LOGICAL_AND,
+    PUNCTUATOR_BITWISE_OR,
+    PUNCTUATOR_BITWISE_XOR,
+    PUNCTUATOR_BITWISE_AND,
+    PUNCTUATOR_EQUAL,
+    PUNCTUATOR_NOT_EQUAL,
+    PUNCTUATOR_STRICT_EQUAL,
+    PUNCTUATOR_NOT_STRICT_EQUAL,
+    PUNCTUATOR_LESS_THAN,
+    PUNCTUATOR_LESS_THAN_EQUAL,
+    PUNCTUATOR_GREATER_THAN,
+    PUNCTUATOR_GREATER_THAN_EQUAL,
+    PUNCTUATOR_LEFT_SHIFT,
+    PUNCTUATOR_RIGHT_SHIFT,
+    PUNCTUATOR_UNSIGNED_RIGHT_SHIFT,
+    PUNCTUATOR_PLUS,
+    PUNCTUATOR_MINUS,
+    PUNCTUATOR_MULTIPLY,
+    PUNCTUATOR_DIVIDE,
+    PUNCTUATOR_MOD,
+    KEYW_IN,
+    KEYW_INSTANCEOF,
+    PUNCTUATOR_EXPONENTIATION,
+
+    PUNCTUATOR_LEFT_PARENTHESIS,
+    PUNCTUATOR_RIGHT_PARENTHESIS,
+    PUNCTUATOR_LEFT_BRACE,
+    PUNCTUATOR_RIGHT_BRACE,
+    PUNCTUATOR_PERIOD,
+    PUNCTUATOR_PERIOD_PERIOD_PERIOD,
+    PUNCTUATOR_PERIOD_QUESTION,
+    PUNCTUATOR_COMMA,
+    PUNCTUATOR_COLON,
+    PUNCTUATOR_SEMI_COLON,
+    PUNCTUATOR_LEFT_SQUARE_BRACKET,
+    PUNCTUATOR_RIGHT_SQUARE_BRACKET,
+    PUNCTUATOR_QUESTION_MARK,
+    PUNCTUATOR_QUESTION_DOT,
+    PUNCTUATOR_TILDE,
+    PUNCTUATOR_EXCLAMATION_MARK,
+    PUNCTUATOR_PLUS_PLUS,
+    PUNCTUATOR_MINUS_MINUS,
+    PUNCTUATOR_SUBSTITUTION,
+    PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL,
+    PUNCTUATOR_RIGHT_SHIFT_EQUAL,
+    PUNCTUATOR_LEFT_SHIFT_EQUAL,
+    PUNCTUATOR_PLUS_EQUAL,
+    PUNCTUATOR_MINUS_EQUAL,
+    PUNCTUATOR_MULTIPLY_EQUAL,
+    PUNCTUATOR_DIVIDE_EQUAL,
+    PUNCTUATOR_MOD_EQUAL,
+    PUNCTUATOR_BITWISE_AND_EQUAL,
+    PUNCTUATOR_BITWISE_OR_EQUAL,
+    PUNCTUATOR_BITWISE_XOR_EQUAL,
+    PUNCTUATOR_LOGICAL_AND_EQUAL,
+    PUNCTUATOR_LOGICAL_OR_EQUAL,
+    PUNCTUATOR_LOGICAL_NULLISH_EQUAL,
+    PUNCTUATOR_EXPONENTIATION_EQUAL,
+    PUNCTUATOR_ARROW,
+    PUNCTUATOR_BACK_TICK,
+    PUNCTUATOR_HASH_MARK,
+    PUNCTUATOR_AT,
+
+    /* contextual keywords */
+    KEYW_GET,
+    KEYW_SET,
+    KEYW_OF,
+    KEYW_FROM,
+    KEYW_AS,
+    KEYW_META,
+    KEYW_REQUIRE,
+    KEYW_ABSTRACT,
+
+    /* reserved keywords */
+    FIRST_KEYW,
+    KEYW_ANY = FIRST_KEYW,
+    KEYW_AWAIT,
+    KEYW_BIGINT,
+    KEYW_BOOLEAN,
+    KEYW_BREAK,
+    KEYW_CASE,
+    KEYW_CATCH,
+    KEYW_CLASS,
+    KEYW_CONST,
+    KEYW_CONTINUE,
+    KEYW_DEBUGGER,
+    KEYW_DEFAULT,
+    KEYW_DELETE,
+    KEYW_DO,
+    KEYW_ELSE,
+    KEYW_ENUM,
+    KEYW_EXPORT,
+    KEYW_EXTENDS,
+    KEYW_FINALLY,
+    KEYW_FOR,
+    KEYW_FUNCTION,
+    KEYW_IF,
+    KEYW_IMPORT,
+    KEYW_NEVER,
+    KEYW_NEW,
+    KEYW_NULL,
+    KEYW_NUMBER,
+    KEYW_OBJECT,
+    KEYW_REGEXP,
+    KEYW_RETURN,
+    KEYW_STRING,
+    KEYW_SUPER,
+    KEYW_SWITCH,
+    KEYW_THIS,
+    KEYW_THROW,
+    KEYW_TYPE,
+    KEYW_TRY,
+    KEYW_TYPEOF,
+    KEYW_UNDEFINED,
+    KEYW_UNKNOWN,
+    KEYW_VAR,
+    KEYW_VOID,
+    KEYW_WHILE,
+    KEYW_WITH,
+
+    KEYW_ASYNC,
+    KEYW_READONLY,
+    KEYW_KEYOF,
+    KEYW_MODULE,
+    KEYW_NAMESPACE,
+    KEYW_INFER,
+    KEYW_DECLARE,
+    KEYW_ARGUMENTS,
+    KEYW_EVAL,
+    KEYW_STATIC,
+    KEYW_GLOBAL,
+    KEYW_IS,
+    KEYW_ASSERTS,
+
+    /* strict mode future reserved keywords */
+    KEYW_PRIVATE,
+    KEYW_PROTECTED,
+    KEYW_PUBLIC,
+    KEYW_IMPLEMENTS,
+    KEYW_INTERFACE,
+    KEYW_PACKAGE,
+
+    /* context dependent future */
+    KEYW_LET,
+    KEYW_YIELD,
+};
+
+const char *TokenToString(TokenType type);
+
+}  // namespace panda::es2panda::lexer
+
+#endif
diff --git a/es2panda/parser/context/parserContext.cpp b/es2panda/parser/context/parserContext.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d67e93039836157a9b931f3eaf2c3dc28a6ffa3
--- /dev/null
+++ b/es2panda/parser/context/parserContext.cpp
@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "parserContext.h"
+
+#include <algorithm>
+
+namespace panda::es2panda::parser {
+const ParserContext *ParserContext::FindLabel(const util::StringView &label) const
+{
+    const auto *iter = this;
+    do {
+        if (iter->label_.Empty()) {
+            return nullptr;
+        }
+
+        if (iter->label_ == label) {
+            return iter;
+        }
+
+        iter = iter->prev_;
+    } while (iter);
+
+    return nullptr;
+}
+}  // namespace panda::es2panda::parser
diff --git a/es2panda/parser/context/parserContext.h b/es2panda/parser/context/parserContext.h
new file mode 100644
index 0000000000000000000000000000000000000000..757a3d5be8ed1d6600a9a3da6fcdd3f53dc537b9
--- /dev/null
+++ b/es2panda/parser/context/parserContext.h
@@ -0,0 +1,137 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_PARSER_PRIVATE_CONTEXT_H
+#define ES2PANDA_PARSER_CORE_PARSER_PRIVATE_CONTEXT_H
+
+#include <macros.h>
+#include <parser/program/program.h>
+#include <util/enumbitops.h>
+#include <util/ustring.h>
+
+#include <vector>
+
+namespace panda::es2panda::parser {
+enum class ParserStatus {
+    NO_OPTS = 0,
+    STRICT = (1 << 0),
+
+    FUNCTION = (1 << 1),
+    ARROW_FUNCTION = (1 << 2),
+    GENERATOR_FUNCTION = (1 << 3),
+    ASYNC_FUNCTION = (1 << 4),
+    CONSTRUCTOR_FUNCTION = (1 << 5),
+    FUNCTION_PARAM = (1 << 6),
+    IS_SPREAD = (1 << 7),
+    ACCESSOR_FUNCTION = (1 << 8),
+    FUNCTION_DECLARATION = (1 << 9),
+
+    ALLOW_SUPER = (1 << 10),
+    ALLOW_SUPER_CALL = (1 << 11),
+
+    DISALLOW_AWAIT = (1 << 12),
+    ALLOW_YIELD = (1 << 13),
+    IN_ITERATION = (1 << 14),
+    IN_LABELED = (1 << 15),
+
+    EXPORT_DEFAULT_REACHED = (1 << 16),
+    HAS_COMPLEX_PARAM = (1 << 17),
+    IN_SWITCH = (1 << 18),
+
+    MODULE = (1 << 19),
+    ALLOW_NEW_TARGET = (1 << 20),
+
+    IN_EXTENDS = (1 << 21),
+    ALLOW_THIS_TYPE = (1 << 22),
+    IN_METHOD_DEFINITION = (1 << 23),
+    IN_AMBIENT_CONTEXT = (1 << 24),
+    IN_CLASS_BODY = (1 << 25),
+    IN_DECORATOR = (1 << 26),
+};
+
+DEFINE_BITOPS(ParserStatus)
+
+class ParserContext {
+public:
+    explicit ParserContext(const Program *program) : program_(program) {}
+    explicit ParserContext(ParserContext *current, ParserStatus newStatus, util::StringView label = "")
+        : program_(current->program_), prev_(current), label_(label)
+    {
+        ParserStatus currentStatus = current->status_;
+        currentStatus &= (ParserStatus::MODULE | ParserStatus::ALLOW_NEW_TARGET | ParserStatus::IN_EXTENDS |
+                          ParserStatus::ALLOW_THIS_TYPE | ParserStatus::IN_CLASS_BODY | ParserStatus::FUNCTION);
+        status_ = currentStatus | newStatus;
+    }
+
+    DEFAULT_COPY_SEMANTIC(ParserContext);
+    DEFAULT_MOVE_SEMANTIC(ParserContext);
+    ~ParserContext() = default;
+
+    const Program *GetProgram() const
+    {
+        return program_;
+    }
+
+    ParserContext *Prev() const
+    {
+        return prev_;
+    }
+
+    const ParserStatus &Status() const
+    {
+        return status_;
+    }
+
+    ParserStatus &Status()
+    {
+        return status_;
+    }
+
+    bool IsGenerator() const
+    {
+        return (status_ & ParserStatus::GENERATOR_FUNCTION) != 0;
+    }
+
+    bool AllowYield() const
+    {
+        return (status_ & ParserStatus::ALLOW_YIELD) != 0;
+    }
+
+    bool DisallowAwait() const
+    {
+        return (status_ & ParserStatus::DISALLOW_AWAIT) != 0;
+    }
+
+    bool IsAsync() const
+    {
+        return (status_ & ParserStatus::ASYNC_FUNCTION) != 0;
+    }
+
+    bool IsModule() const
+    {
+        return (status_ & ParserStatus::MODULE) != 0;
+    }
+
+    const ParserContext *FindLabel(const util::StringView &label) const;
+
+private:
+    const Program *program_;
+    ParserContext *prev_ {};
+    ParserStatus status_ {};
+    util::StringView label_ {};
+};
+}  // namespace panda::es2panda::parser
+
+#endif
diff --git a/es2panda/parser/expressionParser.cpp b/es2panda/parser/expressionParser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..34bb768e9109427fc6fb839cb68b806ecf515744
--- /dev/null
+++ b/es2panda/parser/expressionParser.cpp
@@ -0,0 +1,2344 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/astNode.h>
+#include <ir/base/classDefinition.h>
+#include <ir/base/decorator.h>
+#include <ir/base/metaProperty.h>
+#include <ir/base/methodDefinition.h>
+#include <ir/base/property.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/spreadElement.h>
+#include <ir/base/templateElement.h>
+#include <ir/expression.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/arrowFunctionExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/awaitExpression.h>
+#include <ir/expressions/binaryExpression.h>
+#include <ir/expressions/callExpression.h>
+#include <ir/expressions/chainExpression.h>
+#include <ir/expressions/classExpression.h>
+#include <ir/expressions/conditionalExpression.h>
+#include <ir/expressions/functionExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/importExpression.h>
+#include <ir/expressions/literals/bigIntLiteral.h>
+#include <ir/expressions/literals/booleanLiteral.h>
+#include <ir/expressions/literals/nullLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/regExpLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/newExpression.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/expressions/omittedExpression.h>
+#include <ir/expressions/sequenceExpression.h>
+#include <ir/expressions/superExpression.h>
+#include <ir/expressions/taggedTemplateExpression.h>
+#include <ir/expressions/templateLiteral.h>
+#include <ir/expressions/thisExpression.h>
+#include <ir/expressions/unaryExpression.h>
+#include <ir/expressions/updateExpression.h>
+#include <ir/expressions/yieldExpression.h>
+#include <ir/statements/blockStatement.h>
+#include <ir/ts/tsAsExpression.h>
+#include <ir/ts/tsNonNullExpression.h>
+#include <ir/ts/tsPrivateIdentifier.h>
+#include <ir/ts/tsTypeAssertion.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+#include <ir/ts/tsTypeReference.h>
+#include <ir/validationInfo.h>
+#include <lexer/lexer.h>
+#include <lexer/regexp/regexp.h>
+#include <lexer/token/letters.h>
+#include <lexer/token/sourceLocation.h>
+#include <lexer/token/token.h>
+#include <macros.h>
+
+#include <memory>
+
+#include "parserImpl.h"
+
+namespace panda::es2panda::parser {
+
+ir::YieldExpression *ParserImpl::ParseYieldExpression()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_YIELD);
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+
+    if (lexer_->GetToken().Flags() & lexer::TokenFlags::HAS_ESCAPE) {
+        ThrowSyntaxError("Unexpected identifier");
+    }
+
+    lexer_->NextToken();
+
+    bool isDelegate = false;
+    ir::Expression *argument = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MULTIPLY && !lexer_->GetToken().NewLine()) {
+        isDelegate = true;
+        lexer_->NextToken();
+
+        argument = ParseExpression();
+        endLoc = argument->End();
+    } else if (!lexer_->GetToken().NewLine() && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE &&
+               lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS &&
+               lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET &&
+               lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA &&
+               lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON &&
+               lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON &&
+               lexer_->GetToken().Type() != lexer::TokenType::EOS) {
+        argument = ParseExpression();
+        endLoc = argument->End();
+    }
+
+    auto *yieldNode = AllocNode<ir::YieldExpression>(argument, isDelegate);
+    yieldNode->SetRange({startLoc, endLoc});
+
+    return yieldNode;
+}
+
+ir::Expression *ParserImpl::ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags)
+{
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA &&
+        (flags & ExpressionParseFlags::ACCEPT_COMMA)) {
+        return ParseSequenceExpression(expr, (flags & ExpressionParseFlags::ACCEPT_REST));
+    }
+
+    return expr;
+}
+
+ir::TSAsExpression *ParserImpl::ParseTsAsExpression(ir::Expression *expr, [[maybe_unused]] ExpressionParseFlags flags)
+{
+    lexer_->NextToken();  // eat 'as'
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::ALLOW_CONST;
+    ir::Expression *typeAnnotation = ParseTsTypeAnnotation(&options);
+
+    bool isConst = false;
+    if (typeAnnotation->IsTSTypeReference() && typeAnnotation->AsTSTypeReference()->TypeName()->IsIdentifier()) {
+        const util::StringView &refName = typeAnnotation->AsTSTypeReference()->TypeName()->AsIdentifier()->Name();
+        if (refName.Is("const")) {
+            isConst = true;
+        }
+    }
+
+    lexer::SourcePosition startLoc = expr->Start();
+    auto *asExpr = AllocNode<ir::TSAsExpression>(expr, typeAnnotation, isConst);
+    asExpr->SetRange({startLoc, lexer_->GetToken().End()});
+
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
+        lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AS &&
+        !(flags & ExpressionParseFlags::EXP_DISALLOW_AS)) {
+        return ParseTsAsExpression(asExpr, flags);
+    }
+
+    return asExpr;
+}
+
+ir::Expression *ParserImpl::ParseExpression(ExpressionParseFlags flags)
+{
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_YIELD && !(flags & ExpressionParseFlags::DISALLOW_YIELD)) {
+        ir::YieldExpression *yieldExpr = ParseYieldExpression();
+
+        return ParsePotentialExpressionSequence(yieldExpr, flags);
+    }
+
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        const auto startPos = lexer_->Save();
+
+        // TODO(rsipka): ParseTsGenericArrowFunction and ParseTsTypeAssertion might be in a common function
+        ir::Expression *expr = ParseTsGenericArrowFunction();
+        // TODO(rsipka): negative cases are not covered, probably this is not a complete solution yet
+        if (expr == nullptr) {
+            lexer_->Rewind(startPos);
+            expr = ParseTsTypeAssertion();
+        }
+        return expr;
+    }
+
+    ir::Expression *unaryExpressionNode = ParseUnaryOrPrefixUpdateExpression(flags);
+    ir::Expression *assignmentExpression = ParseAssignmentExpression(unaryExpressionNode, flags);
+
+    if (lexer_->GetToken().NewLine()) {
+        return assignmentExpression;
+    }
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::LITERAL_IDENT: {
+            if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AS &&
+                !(flags & ExpressionParseFlags::EXP_DISALLOW_AS)) {
+                return ParseTsAsExpression(assignmentExpression, flags);
+            }
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_COMMA: {
+            if (flags & ExpressionParseFlags::ACCEPT_COMMA) {
+                return ParseSequenceExpression(assignmentExpression, (flags & ExpressionParseFlags::ACCEPT_REST),
+                                               flags & ExpressionParseFlags::ALLOW_TS_PARAM_TOKEN);
+            }
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    return assignmentExpression;
+}
+
+ir::Expression *ParserImpl::ParseArrayExpression(ExpressionParseFlags flags)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    ArenaVector<ir::Expression *> elements(Allocator()->Adapter());
+
+    lexer_->NextToken();
+
+    bool trailingComma = false;
+    bool inPattern = (flags & ExpressionParseFlags::MUST_BE_PATTERN);
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            auto *omitted = AllocNode<ir::OmittedExpression>();
+            omitted->SetRange(lexer_->GetToken().Loc());
+            elements.push_back(omitted);
+            lexer_->NextToken();
+            continue;
+        }
+
+        ir::Expression *element {};
+        if (inPattern) {
+            element = ParsePatternElement();
+        } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD) {
+            element = ParseSpreadElement(ExpressionParseFlags::POTENTIALLY_IN_PATTERN);
+        } else {
+            element = ParseExpression(ExpressionParseFlags::POTENTIALLY_IN_PATTERN);
+        }
+
+        bool containsRest = element->IsRestElement();
+
+        elements.push_back(element);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            if (containsRest) {
+                ThrowSyntaxError("Rest element must be last element", startLoc);
+            }
+
+            lexer_->NextToken();  // eat comma
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+                trailingComma = true;
+                break;
+            }
+
+            continue;
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+            ThrowSyntaxError("Unexpected token, expected ',' or ']'");
+        }
+    }
+
+    auto nodeType = inPattern ? ir::AstNodeType::ARRAY_PATTERN : ir::AstNodeType::ARRAY_EXPRESSION;
+    auto *arrayExpressionNode = AllocNode<ir::ArrayExpression>(nodeType, std::move(elements), trailingComma);
+    arrayExpressionNode->SetRange({startLoc, lexer_->GetToken().End()});
+    lexer_->NextToken();
+
+    if (inPattern) {
+        arrayExpressionNode->SetDeclaration();
+    }
+
+    if (Extension() == ScriptExtension::TS && (flags & ExpressionParseFlags::ALLOW_TS_PARAM_TOKEN) &&
+        lexer::Token::IsTsParamToken(lexer_->GetToken().Type())) {
+        context_.Status() |= ParserStatus::FUNCTION_PARAM;
+        ParsePotentialTsFunctionParameter(ExpressionParseFlags::NO_OPTS, arrayExpressionNode);
+    }
+
+    if (!(flags & ExpressionParseFlags::POTENTIALLY_IN_PATTERN)) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION &&
+            !arrayExpressionNode->ConvertibleToArrayPattern()) {
+            ThrowSyntaxError("Invalid left-hand side in array destructuring pattern", arrayExpressionNode->Start());
+        } else if (!inPattern && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+            ir::ValidationInfo info = arrayExpressionNode->ValidateExpression();
+            if (info.Fail()) {
+                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+            }
+        }
+    }
+
+    return arrayExpressionNode;
+}
+
+ParserStatus ParserImpl::ValidateArrowParameter(ir::Expression *expr)
+{
+    switch (expr->Type()) {
+        case ir::AstNodeType::SPREAD_ELEMENT: {
+            if (!expr->AsSpreadElement()->ConvertibleToRest(true)) {
+                ThrowSyntaxError("Invalid rest element.");
+            }
+
+            [[fallthrough]];
+        }
+        case ir::AstNodeType::REST_ELEMENT: {
+            ValidateArrowParameterBindings(expr->AsRestElement()->Argument());
+            return ParserStatus::HAS_COMPLEX_PARAM;
+        }
+        case ir::AstNodeType::IDENTIFIER: {
+            const util::StringView &identifier = expr->AsIdentifier()->Name();
+
+            if (identifier.Is("arguments")) {
+                ThrowSyntaxError("Binding 'arguments' in strict mode is invalid");
+            } else if (identifier.Is("eval")) {
+                ThrowSyntaxError("Binding 'eval' in strict mode is invalid");
+            }
+
+            ValidateArrowParameterBindings(expr);
+            return ParserStatus::NO_OPTS;
+        }
+        case ir::AstNodeType::OBJECT_EXPRESSION: {
+            ir::ObjectExpression *objectPattern = expr->AsObjectExpression();
+
+            if (!objectPattern->ConvertibleToObjectPattern()) {
+                ThrowSyntaxError("Invalid destructuring assignment target");
+            }
+
+            ValidateArrowParameterBindings(expr);
+            return ParserStatus::HAS_COMPLEX_PARAM;
+        }
+        case ir::AstNodeType::ARRAY_EXPRESSION: {
+            ir::ArrayExpression *arrayPattern = expr->AsArrayExpression();
+
+            if (!arrayPattern->ConvertibleToArrayPattern()) {
+                ThrowSyntaxError("Invalid destructuring assignment target");
+            }
+
+            ValidateArrowParameterBindings(expr);
+            return ParserStatus::HAS_COMPLEX_PARAM;
+        }
+        case ir::AstNodeType::ASSIGNMENT_EXPRESSION: {
+            auto *assignmentExpr = expr->AsAssignmentExpression();
+            if (assignmentExpr->Right()->IsYieldExpression()) {
+                ThrowSyntaxError("yield is not allowed in arrow function parameters");
+            }
+
+            if (assignmentExpr->Right()->IsAwaitExpression()) {
+                ThrowSyntaxError("await is not allowed in arrow function parameters");
+            }
+
+            if (!assignmentExpr->ConvertibleToAssignmentPattern()) {
+                ThrowSyntaxError("Invalid destructuring assignment target");
+            }
+
+            ValidateArrowParameterBindings(expr);
+            return ParserStatus::HAS_COMPLEX_PARAM;
+        }
+        default: {
+            break;
+        }
+    }
+    ThrowSyntaxError("Insufficient formal parameter in arrow function.");
+    return ParserStatus::NO_OPTS;
+}
+
+ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowFunctionContext *arrowFunctionContext,
+                                                                          binder::FunctionScope *functionScope,
+                                                                          ArrowFunctionDescriptor *desc,
+                                                                          ir::TSTypeParameterDeclaration *typeParamDecl,
+                                                                          ir::Expression *returnTypeAnnotation)
+{
+    context_.Status() |= desc->newStatus;
+
+    functionScope->BindParamScope(desc->paramScope);
+    desc->paramScope->BindFunctionScope(functionScope);
+
+    lexer_->NextToken();  // eat '=>'
+    ir::ScriptFunction *funcNode {};
+
+    ir::AstNode *body = nullptr;
+    lexer::SourcePosition endLoc;
+    lexer::SourcePosition bodyStart = lexer_->GetToken().Start();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        body = ParseExpression();
+        endLoc = body->AsExpression()->End();
+        arrowFunctionContext->AddFlag(ir::ScriptFunctionFlags::EXPRESSION);
+    } else {
+        lexer_->NextToken();
+        auto statements = ParseStatementList();
+        body = AllocNode<ir::BlockStatement>(functionScope, std::move(statements));
+        body->SetRange({bodyStart, lexer_->GetToken().End()});
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+            ThrowSyntaxError("Expected a '}'");
+        }
+
+        lexer_->NextToken();
+        endLoc = body->End();
+    }
+
+    funcNode = AllocNode<ir::ScriptFunction>(functionScope, std::move(desc->params), typeParamDecl, body,
+                                             returnTypeAnnotation, arrowFunctionContext->Flags(), false);
+    funcNode->SetRange({desc->startLoc, endLoc});
+    functionScope->BindNode(funcNode);
+    desc->paramScope->BindNode(funcNode);
+
+    auto *arrowFuncNode = AllocNode<ir::ArrowFunctionExpression>(funcNode);
+    arrowFuncNode->SetRange(funcNode->Range());
+
+    return arrowFuncNode;
+}
+
+ArrowFunctionDescriptor ParserImpl::ConvertToArrowParameter(ir::Expression *expr, bool isAsync,
+                                                            binder::FunctionParamScope *paramScope)
+{
+    auto arrowStatus = isAsync ? ParserStatus::ASYNC_FUNCTION : ParserStatus::NO_OPTS;
+    ArenaVector<ir::Expression *> params(Allocator()->Adapter());
+
+    if (!expr) {
+        return ArrowFunctionDescriptor {std::move(params), paramScope, lexer_->GetToken().Start(), arrowStatus};
+    }
+
+    switch (expr->Type()) {
+        case ir::AstNodeType::REST_ELEMENT:
+        case ir::AstNodeType::IDENTIFIER:
+        case ir::AstNodeType::OBJECT_EXPRESSION:
+        case ir::AstNodeType::ASSIGNMENT_EXPRESSION:
+        case ir::AstNodeType::ARRAY_EXPRESSION: {
+            arrowStatus |= ValidateArrowParameter(expr);
+
+            params.push_back(expr);
+            break;
+        }
+        case ir::AstNodeType::SEQUENCE_EXPRESSION: {
+            auto &sequence = expr->AsSequenceExpression()->Sequence();
+
+            for (auto *it : sequence) {
+                arrowStatus |= ValidateArrowParameter(it);
+            }
+
+            params.swap(sequence);
+            break;
+        }
+        case ir::AstNodeType::CALL_EXPRESSION: {
+            if (isAsync) {
+                auto &arguments = expr->AsCallExpression()->Arguments();
+
+                for (auto *it : arguments) {
+                    arrowStatus |= ValidateArrowParameter(it);
+                }
+
+                params.swap(arguments);
+                break;
+            }
+
+            [[fallthrough]];
+        }
+        default: {
+            ThrowSyntaxError("Unexpected token, arrow (=>)");
+        }
+    }
+
+    for (const auto *param : params) {
+        Binder()->AddParamDecl(param);
+    }
+
+    return ArrowFunctionDescriptor {std::move(params), paramScope, expr->Start(), arrowStatus};
+}
+
+ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpression(ir::Expression *expr,
+                                                                      ir::TSTypeParameterDeclaration *typeParamDecl,
+                                                                      ir::Expression *returnTypeAnnotation,
+                                                                      bool isAsync)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_ARROW);
+
+    if (lexer_->GetToken().NewLine()) {
+        ThrowSyntaxError(
+            "expected '=>' on the same line after an argument list, "
+            "got line terminator");
+    }
+
+    ArrowFunctionContext arrowFunctionContext(this, isAsync);
+    FunctionParameterContext functionParamContext(&context_, Binder());
+    ArrowFunctionDescriptor desc =
+        ConvertToArrowParameter(expr, isAsync, functionParamContext.LexicalScope().GetScope());
+
+    auto functionCtx = binder::LexicalScope<binder::FunctionScope>(Binder());
+    return ParseArrowFunctionExpressionBody(&arrowFunctionContext, functionCtx.GetScope(), &desc, typeParamDecl,
+                                            returnTypeAnnotation);
+}
+
+ir::ArrowFunctionExpression *ParserImpl::ParseTsGenericArrowFunction()
+{
+    ArrowFunctionContext arrowFunctionContext(this, false);
+
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN);
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    ir::TSTypeParameterDeclaration *typeParamDecl = ParseTsTypeParameterDeclaration(false);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        return nullptr;
+    }
+
+    FunctionParameterContext funcParamContext(&context_, Binder());
+    ArenaVector<ir::Expression *> params = ParseFunctionParams(true);
+
+    ParserStatus arrowStatus = ParserStatus::NO_OPTS;
+
+    if (std::any_of(params.begin(), params.end(), [](const auto *param) { return !param->IsIdentifier(); })) {
+        arrowStatus = ParserStatus::HAS_COMPLEX_PARAM;
+    }
+
+    ir::Expression *returnTypeAnnotation = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+        lexer_->NextToken();  // eat ':'
+        TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+        returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_ARROW) {
+        return nullptr;
+    }
+
+    ArrowFunctionDescriptor desc(std::move(params), funcParamContext.LexicalScope().GetScope(), startLoc, arrowStatus);
+
+    auto functionCtx = binder::LexicalScope<binder::FunctionScope>(Binder());
+    return ParseArrowFunctionExpressionBody(&arrowFunctionContext, functionCtx.GetScope(), &desc, typeParamDecl,
+                                            returnTypeAnnotation);
+}
+
+ir::TSTypeAssertion *ParserImpl::ParseTsTypeAssertion()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN);
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat '<'
+
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+    ir::Expression *typeAnnotation = ParseTsTypeAnnotation(&options);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_GREATER_THAN) {
+        return nullptr;
+    }
+
+    lexer_->NextToken();  // eat '>'
+    ir::Expression *expression = ParseExpression();
+    auto *typeAssertion = AllocNode<ir::TSTypeAssertion>(typeAnnotation, expression);
+    typeAssertion->SetRange({start, lexer_->GetToken().End()});
+
+    return typeAssertion;
+}
+
+ir::Expression *ParserImpl::ParseCoverParenthesizedExpressionAndArrowParameterList()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS);
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+    lexer_->NextToken();
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD) {
+        ir::SpreadElement *restElement = ParseSpreadElement(ExpressionParseFlags::MUST_BE_PATTERN);
+
+        restElement->SetGrouped();
+        restElement->SetStart(start);
+
+        if (Extension() == ScriptExtension::TS && lexer::Token::IsTsParamToken(lexer_->GetToken().Type())) {
+            ParsePotentialTsFunctionParameter(ExpressionParseFlags::IN_REST, restElement);
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+            ThrowSyntaxError("Rest parameter must be last formal parameter");
+        }
+
+        lexer_->NextToken();
+
+        ir::Expression *returnTypeAnnotation = nullptr;
+        if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+            lexer_->NextToken();  // eat ':'
+            returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_ARROW) {
+            ThrowSyntaxError("Unexpected token");
+        }
+
+        return ParseArrowFunctionExpression(restElement, nullptr, returnTypeAnnotation, false);
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        lexer_->NextToken();
+
+        ir::Expression *returnTypeAnnotation = nullptr;
+        if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+            lexer_->NextToken();  // eat ':'
+            returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_ARROW) {
+            ThrowSyntaxError("Unexpected token");
+        }
+
+        auto *arrowExpr = ParseArrowFunctionExpression(nullptr, nullptr, returnTypeAnnotation, false);
+        arrowExpr->SetStart(start);
+        arrowExpr->AsArrowFunctionExpression()->Function()->SetStart(start);
+
+        return arrowExpr;
+    }
+
+    ir::Expression *expr =
+        ParseExpression(ExpressionParseFlags::ACCEPT_COMMA | ExpressionParseFlags::ACCEPT_REST |
+                        ExpressionParseFlags::POTENTIALLY_IN_PATTERN | ExpressionParseFlags::ALLOW_TS_PARAM_TOKEN);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token, expected ')'");
+    }
+
+    expr->SetGrouped();
+    expr->SetRange({start, lexer_->GetToken().End()});
+    lexer_->NextToken();
+
+    if (Extension() == ScriptExtension::TS && ((context_.Status() & ParserStatus::FUNCTION_PARAM) ||
+                                               lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON)) {
+        context_.Status() &= ~ParserStatus::FUNCTION_PARAM;
+
+        ir::Expression *returnTypeAnnotation = nullptr;
+        const auto startPos = lexer_->Save();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+            lexer_->NextToken();  // eat ':'
+            options = ~TypeAnnotationParsingOptions::THROW_ERROR;
+            returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_ARROW) {
+            lexer_->Rewind(startPos);
+            return expr;
+            // ThrowSyntaxError("'=>' expected.");
+        }
+
+        return ParseArrowFunctionExpression(expr, nullptr, returnTypeAnnotation, false);
+    }
+
+    return expr;
+}
+
+void ParserImpl::CheckInvalidDestructuring(const ir::AstNode *object) const
+{
+    object->Iterate([this](ir::AstNode *childNode) -> void {
+        switch (childNode->Type()) {
+            case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+                ThrowSyntaxError("Invalid property initializer");
+                break;
+            }
+            case ir::AstNodeType::REST_ELEMENT:
+            case ir::AstNodeType::PROPERTY:
+            case ir::AstNodeType::OBJECT_EXPRESSION: {
+                CheckInvalidDestructuring(childNode);
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+    });
+}
+
+void ParserImpl::ValidateParenthesizedExpression(ir::Expression *lhsExpression)
+{
+    switch (lhsExpression->Type()) {
+        case ir::AstNodeType::IDENTIFIER:
+        case ir::AstNodeType::MEMBER_EXPRESSION: {
+            break;
+        }
+        case ir::AstNodeType::ARRAY_EXPRESSION: {
+            auto info = lhsExpression->AsArrayExpression()->ValidateExpression();
+            if (info.Fail()) {
+                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+            }
+            break;
+        }
+        case ir::AstNodeType::OBJECT_EXPRESSION: {
+            auto info = lhsExpression->AsObjectExpression()->ValidateExpression();
+            if (info.Fail()) {
+                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+            }
+            break;
+        }
+        case ir::AstNodeType::ASSIGNMENT_EXPRESSION: {
+            if (lhsExpression->AsAssignmentExpression()->ConvertibleToAssignmentPattern(false)) {
+                break;
+            }
+            [[fallthrough]];
+        }
+        case ir::AstNodeType::SPREAD_ELEMENT: {
+            ThrowSyntaxError("Invalid left-hand side in assignment expression");
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+ir::Expression *ParserImpl::ParseAssignmentExpression(ir::Expression *lhsExpression, ExpressionParseFlags flags)
+{
+    lexer::TokenType tokenType = lexer_->GetToken().Type();
+    if (lhsExpression->IsGrouped() && tokenType != lexer::TokenType::PUNCTUATOR_ARROW) {
+        if (lhsExpression->IsSequenceExpression()) {
+            for (auto *seq : lhsExpression->AsSequenceExpression()->Sequence()) {
+                ValidateParenthesizedExpression(seq);
+            }
+        } else {
+            ValidateParenthesizedExpression(lhsExpression);
+        }
+    }
+
+    switch (tokenType) {
+        case lexer::TokenType::PUNCTUATOR_QUESTION_MARK: {
+            lexer_->NextToken();
+            ir::Expression *consequent = ParseExpression();
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON) {
+                ThrowSyntaxError("Unexpected token, expected ':'");
+            }
+
+            lexer_->NextToken();
+            ir::Expression *alternate = ParseExpression();
+
+            auto *conditionalExpr = AllocNode<ir::ConditionalExpression>(lhsExpression, consequent, alternate);
+            conditionalExpr->SetRange({lhsExpression->Start(), alternate->End()});
+            return conditionalExpr;
+        }
+        case lexer::TokenType::PUNCTUATOR_ARROW: {
+            if (lexer_->GetToken().NewLine()) {
+                ThrowSyntaxError("Uncaught SyntaxError: expected expression, got '=>'");
+            }
+
+            return ParseArrowFunctionExpression(lhsExpression, nullptr, nullptr, false);
+        }
+        case lexer::TokenType::KEYW_IN: {
+            if (flags & ExpressionParseFlags::STOP_AT_IN) {
+                break;
+            }
+
+            [[fallthrough]];
+        }
+        case lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING:
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_OR:
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_AND:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND:
+        case lexer::TokenType::PUNCTUATOR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_NOT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN:
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN:
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_PLUS:
+        case lexer::TokenType::PUNCTUATOR_MINUS:
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE:
+        case lexer::TokenType::PUNCTUATOR_MOD:
+        case lexer::TokenType::KEYW_INSTANCEOF:
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION: {
+            ir::Expression *binaryExpression = ParseBinaryExpression(lhsExpression);
+
+            return ParseAssignmentExpression(binaryExpression);
+        }
+        case lexer::TokenType::PUNCTUATOR_SUBSTITUTION: {
+            ValidateAssignmentTarget(flags, lhsExpression);
+
+            lexer_->NextToken();
+            ir::Expression *assignmentExpression = ParseExpression(CarryPatternFlags(flags));
+
+            auto *binaryAssignmentExpression =
+                AllocNode<ir::AssignmentExpression>(lhsExpression, assignmentExpression, tokenType);
+
+            binaryAssignmentExpression->SetRange({lhsExpression->Start(), assignmentExpression->End()});
+            return binaryAssignmentExpression;
+        }
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_PLUS_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MINUS_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MOD_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_AND_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_OR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_NULLISH_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL: {
+            ValidateLvalueAssignmentTarget(lhsExpression);
+
+            lexer_->NextToken();
+            ir::Expression *assignmentExpression = ParseExpression(CarryPatternFlags(flags));
+
+            auto *binaryAssignmentExpression =
+                AllocNode<ir::AssignmentExpression>(lhsExpression, assignmentExpression, tokenType);
+
+            binaryAssignmentExpression->SetRange({lhsExpression->Start(), assignmentExpression->End()});
+            return binaryAssignmentExpression;
+        }
+        default:
+            break;
+    }
+
+    return lhsExpression;
+}
+
+ir::TemplateLiteral *ParserImpl::ParseTemplateLiteral()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    ArenaVector<ir::TemplateElement *> quasis(Allocator()->Adapter());
+    ArenaVector<ir::Expression *> expressions(Allocator()->Adapter());
+
+    while (true) {
+        lexer_->ResetTokenEnd();
+        const auto startPos = lexer_->Save();
+
+        lexer_->ScanString<LEX_CHAR_BACK_TICK>();
+        util::StringView cooked = lexer_->GetToken().String();
+
+        lexer_->Rewind(startPos);
+        auto [raw, end, scanExpression] = lexer_->ScanTemplateString();
+
+        auto *element = AllocNode<ir::TemplateElement>(raw.View(), cooked);
+        element->SetRange({lexer::SourcePosition {startPos.iterator.Index(), startPos.line},
+                           lexer::SourcePosition {end, lexer_->Line()}});
+        quasis.push_back(element);
+
+        if (!scanExpression) {
+            lexer_->ScanTemplateStringEnd();
+            break;
+        }
+
+        ir::Expression *expression = nullptr;
+
+        {
+            lexer::TemplateLiteralParserContext ctx(lexer_);
+            lexer_->PushTemplateContext(&ctx);
+            lexer_->NextToken();
+            expression = ParseExpression();
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+            ThrowSyntaxError("Unexpected token, expected '}'.");
+        }
+
+        expressions.push_back(expression);
+    }
+
+    auto *templateNode = AllocNode<ir::TemplateLiteral>(std::move(quasis), std::move(expressions));
+    templateNode->SetRange({startLoc, lexer_->GetToken().End()});
+
+    lexer_->NextToken();
+
+    return templateNode;
+}
+
+ir::NewExpression *ParserImpl::ParseNewExpression()
+{
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+
+    lexer_->NextToken();  // eat new
+
+    // parse callee part of NewExpression
+    ir::Expression *callee = ParseMemberExpression(true);
+    if (callee->IsImportExpression() && !callee->IsGrouped()) {
+        ThrowSyntaxError("Cannot use new with import(...)");
+    }
+
+    ArenaVector<ir::Expression *> arguments(Allocator()->Adapter());
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        lexer::SourcePosition endLoc = callee->End();
+        auto *newExprNode = AllocNode<ir::NewExpression>(callee, std::move(arguments));
+        newExprNode->SetRange({start, endLoc});
+
+        return newExprNode;
+    }
+
+    lexer_->NextToken();  // eat left pranthesis
+
+    // parse argument part of NewExpression
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ir::Expression *argument = nullptr;
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD) {
+            argument = ParseSpreadElement();
+        } else {
+            argument = ParseExpression();
+        }
+
+        arguments.push_back(argument);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            lexer_->NextToken();  // eat comma
+        }
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::EOS) {
+            ThrowSyntaxError("Unexpected token in argument parsing");
+        }
+    }
+
+    auto *newExprNode = AllocNode<ir::NewExpression>(callee, std::move(arguments));
+    newExprNode->SetRange({start, lexer_->GetToken().End()});
+
+    lexer_->NextToken();
+
+    return newExprNode;
+}
+
+ir::Expression *ParserImpl::ParseLeftHandSideExpression(ExpressionParseFlags flags)
+{
+    return ParseMemberExpression(false, flags);
+}
+
+ir::MetaProperty *ParserImpl::ParsePotentialNewTarget()
+{
+    lexer::SourceRange loc = lexer_->GetToken().Loc();
+
+    if (lexer_->Lookahead() == LEX_CHAR_DOT) {
+        lexer_->NextToken();
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT && lexer_->GetToken().Ident().Is("target")) {
+            if (!(context_.Status() & ParserStatus::ALLOW_NEW_TARGET)) {
+                ThrowSyntaxError("'new.Target' is not allowed here");
+            }
+
+            if (lexer_->GetToken().Flags() & lexer::TokenFlags::HAS_ESCAPE) {
+                ThrowSyntaxError("'new.Target' must not contain escaped characters");
+            }
+
+            auto *metaProperty = AllocNode<ir::MetaProperty>(ir::MetaProperty::MetaPropertyKind::NEW_TARGET);
+            metaProperty->SetRange(loc);
+            lexer_->NextToken();
+            return metaProperty;
+        }
+    }
+
+    return nullptr;
+}
+
+ir::Expression *ParserImpl::ParsePrimaryExpression(ExpressionParseFlags flags)
+{
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::KEYW_IMPORT: {
+            return ParseImportExpression();
+        }
+        case lexer::TokenType::LITERAL_IDENT: {
+            auto *identNode = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+            identNode->SetReference();
+            identNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+
+            if (Extension() == ScriptExtension::TS && (flags & ExpressionParseFlags::ALLOW_TS_PARAM_TOKEN) &&
+                lexer::Token::IsTsParamToken(lexer_->GetToken().Type())) {
+                context_.Status() |= ParserStatus::FUNCTION_PARAM;
+                ParsePotentialTsFunctionParameter(ExpressionParseFlags::NO_OPTS, identNode);
+            }
+
+            return identNode;
+        }
+        case lexer::TokenType::LITERAL_TRUE: {
+            auto *trueNode = AllocNode<ir::BooleanLiteral>(true);
+            trueNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+            return trueNode;
+        }
+        case lexer::TokenType::LITERAL_FALSE: {
+            auto *falseNode = AllocNode<ir::BooleanLiteral>(false);
+            falseNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+            return falseNode;
+        }
+        case lexer::TokenType::LITERAL_NULL: {
+            auto *nullNode = AllocNode<ir::NullLiteral>();
+            nullNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+            return nullNode;
+        }
+        case lexer::TokenType::LITERAL_NUMBER: {
+            ir::Expression *numberNode = nullptr;
+
+            if (lexer_->GetToken().Flags() & lexer::TokenFlags::NUMBER_BIGINT) {
+                numberNode = AllocNode<ir::BigIntLiteral>(lexer_->GetToken().BigInt());
+            } else {
+                numberNode = AllocNode<ir::NumberLiteral>(lexer_->GetToken().Number(), lexer_->GetToken().String());
+            }
+
+            numberNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+            return numberNode;
+        }
+        case lexer::TokenType::LITERAL_STRING: {
+            auto *stringNode = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+            stringNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+            return stringNode;
+        }
+        case lexer::TokenType::PUNCTUATOR_DIVIDE:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL: {
+            lexer_->ResetTokenEnd();
+            auto regexp = lexer_->ScanRegExp();
+
+            lexer::RegExpParser reParser(regexp, Allocator());
+
+            try {
+                reParser.ParsePattern();
+            } catch (lexer::RegExpError &e) {
+                ThrowSyntaxError(e.message.c_str());
+            }
+
+            auto *regexpNode = AllocNode<ir::RegExpLiteral>(regexp.patternStr, regexp.flagsStr);
+            regexpNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+            return regexpNode;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET: {
+            return ParseArrayExpression(CarryPatternFlags(flags));
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS: {
+            return ParseCoverParenthesizedExpressionAndArrowParameterList();
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_BRACE: {
+            return ParseObjectExpression(CarryPatternFlags(flags));
+        }
+        case lexer::TokenType::KEYW_FUNCTION: {
+            return ParseFunctionExpression();
+        }
+        case lexer::TokenType::KEYW_CLASS: {
+            lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+            ir::ClassDefinition *classDefinition = ParseClassDefinition(false);
+
+            auto *classExpr = AllocNode<ir::ClassExpression>(classDefinition);
+            classExpr->SetRange({startLoc, classDefinition->End()});
+
+            return classExpr;
+        }
+        case lexer::TokenType::KEYW_THIS: {
+            auto *thisExprNode = AllocNode<ir::ThisExpression>();
+            thisExprNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();  // eat this
+            return thisExprNode;
+        }
+        case lexer::TokenType::KEYW_SUPER: {
+            auto *superExprNode = AllocNode<ir::SuperExpression>();
+            superExprNode->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();  // eat super
+
+            if ((lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD ||
+                 lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET) &&
+                (context_.Status() & ParserStatus::ALLOW_SUPER)) {
+                return superExprNode;
+            }
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS &&
+                (context_.Status() & ParserStatus::ALLOW_SUPER_CALL)) {
+                return superExprNode;
+            }
+
+            ThrowSyntaxError("Unexpected super keyword");
+        }
+        case lexer::TokenType::KEYW_NEW: {
+            ir::MetaProperty *newTarget = ParsePotentialNewTarget();
+
+            if (newTarget) {
+                return newTarget;
+            }
+
+            return ParseNewExpression();
+        }
+        case lexer::TokenType::PUNCTUATOR_BACK_TICK: {
+            return ParseTemplateLiteral();
+        }
+        default: {
+            break;
+        }
+    }
+
+    ThrowSyntaxError("Primary expression expected");
+    return nullptr;
+}
+
+static size_t GetOperatorPrecedence(lexer::TokenType operatorType)
+{
+    ASSERT(lexer::Token::IsBinaryToken(operatorType));
+
+    switch (operatorType) {
+        case lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING: {
+            constexpr auto precedence = 1;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_OR: {
+            constexpr auto precedence = 2;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_LOGICAL_AND:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR: {
+            constexpr auto precedence = 3;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR: {
+            constexpr auto precedence = 4;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND: {
+            constexpr auto precedence = 5;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_NOT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL: {
+            constexpr auto precedence = 6;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN:
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN:
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL:
+        case lexer::TokenType::KEYW_INSTANCEOF:
+        case lexer::TokenType::KEYW_IN: {
+            constexpr auto precedence = 7;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT:
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT: {
+            constexpr auto precedence = 8;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_PLUS:
+        case lexer::TokenType::PUNCTUATOR_MINUS: {
+            constexpr auto precedence = 9;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE:
+        case lexer::TokenType::PUNCTUATOR_MOD: {
+            const auto precedence = 10;
+            return precedence;
+        }
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION: {
+            constexpr auto precedence = 11;
+            return precedence;
+        }
+        default: {
+           UNREACHABLE();
+        }
+    }
+}
+
+static inline bool ShouldBinaryExpressionBeAmended(ir::BinaryExpression *binaryExpression,
+                                                   lexer::TokenType operatorType)
+{
+    return GetOperatorPrecedence(binaryExpression->OperatorType()) <= GetOperatorPrecedence(operatorType) &&
+           !binaryExpression->IsGrouped() &&
+           (operatorType != lexer::TokenType::PUNCTUATOR_EXPONENTIATION ||
+            binaryExpression->OperatorType() != lexer::TokenType::PUNCTUATOR_EXPONENTIATION);
+}
+
+ir::Expression *ParserImpl::ParseBinaryExpression(ir::Expression *left)
+{
+    lexer::TokenType operatorType = lexer_->GetToken().Type();
+    ASSERT(lexer::Token::IsBinaryToken(operatorType));
+
+    if (operatorType == lexer::TokenType::PUNCTUATOR_EXPONENTIATION) {
+        if (left->IsUnaryExpression() && !left->IsGrouped()) {
+            ThrowSyntaxError(
+                "Illegal expression. Wrap left hand side or entire "
+                "exponentiation in parentheses.");
+        }
+    }
+
+    lexer_->NextToken();
+
+    ir::Expression *rightExprNode = ParseExpression(ExpressionParseFlags::DISALLOW_YIELD);
+
+    ir::Expression *rightExpr = rightExprNode;
+    ir::ConditionalExpression *conditionalExpr = nullptr;
+
+    if (rightExpr->IsConditionalExpression() && !rightExpr->IsGrouped()) {
+        conditionalExpr = rightExpr->AsConditionalExpression();
+        rightExpr = conditionalExpr->Test();
+    }
+
+    if (rightExpr->IsBinaryExpression() &&
+        ShouldBinaryExpressionBeAmended(rightExpr->AsBinaryExpression(), operatorType)) {
+        if ((operatorType == lexer::TokenType::PUNCTUATOR_LOGICAL_OR ||
+             operatorType == lexer::TokenType::PUNCTUATOR_LOGICAL_AND) &&
+            rightExpr->AsBinaryExpression()->OperatorType() == lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING) {
+            ThrowSyntaxError("Nullish coalescing operator ?? requires parens when mixing with logical operators.");
+        }
+
+        bool shouldBeAmended = true;
+
+        ir::BinaryExpression *binaryExpression = rightExpr->AsBinaryExpression();
+        ir::BinaryExpression *parentExpression = nullptr;
+
+        while (binaryExpression->Left()->IsBinaryExpression() && shouldBeAmended) {
+            parentExpression = binaryExpression;
+            parentExpression->SetStart(left->Start());
+            binaryExpression = binaryExpression->Left()->AsBinaryExpression();
+            shouldBeAmended = ShouldBinaryExpressionBeAmended(binaryExpression, operatorType);
+        }
+
+        if (shouldBeAmended) {
+            auto *leftExprNode = AllocNode<ir::BinaryExpression>(left, binaryExpression->Left(), operatorType);
+            leftExprNode->SetRange({left->Start(), binaryExpression->Left()->End()});
+
+            binaryExpression->SetLeft(leftExprNode);
+        } else {
+            // Transfer the parent's left ownership to right_node
+            ir::Expression *rightNode = parentExpression->Left();
+
+            auto *binaryOrLogicalExpressionNode = AllocNode<ir::BinaryExpression>(left, rightNode, operatorType);
+            binaryOrLogicalExpressionNode->SetRange({left->Start(), rightNode->End()});
+
+            parentExpression->SetLeft(binaryOrLogicalExpressionNode);
+        }
+    } else {
+        if (operatorType == lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING && rightExpr->IsBinaryExpression() &&
+            rightExpr->AsBinaryExpression()->IsLogical() && !rightExpr->IsGrouped()) {
+            ThrowSyntaxError("Nullish coalescing operator ?? requires parens when mixing with logical operators.");
+        }
+        const lexer::SourcePosition &endPos = rightExpr->End();
+        rightExpr = AllocNode<ir::BinaryExpression>(left, rightExpr, operatorType);
+        rightExpr->SetRange({left->Start(), endPos});
+    }
+
+    if (conditionalExpr != nullptr) {
+        conditionalExpr->SetStart(rightExpr->Start());
+        conditionalExpr->SetTest(rightExpr);
+        return conditionalExpr;
+    }
+
+    return rightExpr;
+}
+
+ir::CallExpression *ParserImpl::ParseCallExpression(ir::Expression *callee, bool isOptionalChain, bool isAsync)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS);
+
+    while (true) {
+        lexer_->NextToken();
+        ArenaVector<ir::Expression *> arguments(Allocator()->Adapter());
+
+        while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+            ir::Expression *argument = nullptr;
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD) {
+                argument = ParseSpreadElement();
+            } else {
+                argument = ParseExpression(isAsync ? ExpressionParseFlags::ALLOW_TS_PARAM_TOKEN
+                                                   : ExpressionParseFlags::NO_OPTS);
+            }
+
+            arguments.push_back(argument);
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+                lexer_->NextToken();
+            } else if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+                ThrowSyntaxError("Expected a ')'");
+            }
+        }
+
+        auto *callExpr = AllocNode<ir::CallExpression>(callee, std::move(arguments), nullptr, isOptionalChain);
+        callExpr->SetRange({callee->Start(), lexer_->GetToken().End()});
+        isOptionalChain = false;
+
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+            return callExpr;
+        }
+
+        callee = callExpr;
+    }
+
+    UNREACHABLE();
+    return nullptr;
+}
+
+ir::Expression *ParserImpl::ParseOptionalChain(ir::Expression *leftSideExpr)
+{
+    lexer::TokenType tokenType = lexer_->GetToken().Type();
+    ir::Expression *returnExpression = nullptr;
+
+    if (tokenType == lexer::TokenType::LITERAL_IDENT) {
+        auto *identNode = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        identNode->SetReference();
+        identNode->SetRange(lexer_->GetToken().Loc());
+
+        returnExpression = AllocNode<ir::MemberExpression>(
+            leftSideExpr, identNode, ir::MemberExpression::MemberExpressionKind::PROPERTY_ACCESS, false, true);
+        returnExpression->SetRange({leftSideExpr->Start(), identNode->End()});
+        lexer_->NextToken();
+    }
+
+    if (tokenType == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET) {
+        lexer_->NextToken();  // eat '['
+        ir::Expression *propertyNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+            ThrowSyntaxError("Unexpected token");
+        }
+
+        returnExpression = AllocNode<ir::MemberExpression>(
+            leftSideExpr, propertyNode, ir::MemberExpression::MemberExpressionKind::ELEMENT_ACCESS, true, true);
+        returnExpression->SetRange({leftSideExpr->Start(), lexer_->GetToken().End()});
+        lexer_->NextToken();
+    }
+
+    if (tokenType == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        returnExpression = ParseCallExpression(leftSideExpr, true);
+    }
+
+    // Static semantic
+    if (tokenType == lexer::TokenType::PUNCTUATOR_BACK_TICK ||
+        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_BACK_TICK) {
+        ThrowSyntaxError("Tagged Template Literals are not allowed in optionalChain");
+    }
+
+    return returnExpression;
+}
+
+ir::ArrowFunctionExpression *ParserImpl::ParsePotentialArrowExpression(ir::Expression **returnExpression,
+                                                                       const lexer::SourcePosition &startLoc)
+{
+    ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::KEYW_FUNCTION: {
+            *returnExpression = ParseFunctionExpression(ParserStatus::ASYNC_FUNCTION);
+            (*returnExpression)->SetStart(startLoc);
+            break;
+        }
+        case lexer::TokenType::LITERAL_IDENT: {
+            ir::Expression *identRef = ParsePrimaryExpression();
+            ASSERT(identRef->IsIdentifier());
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_ARROW) {
+                ThrowSyntaxError("Unexpected token, expected '=>'");
+            }
+
+            ir::ArrowFunctionExpression *arrowFuncExpr = ParseArrowFunctionExpression(identRef, nullptr, nullptr, true);
+            arrowFuncExpr->SetStart(startLoc);
+
+            return arrowFuncExpr;
+        }
+        case lexer::TokenType::PUNCTUATOR_ARROW: {
+            ir::ArrowFunctionExpression *arrowFuncExpr =
+                ParseArrowFunctionExpression(*returnExpression, nullptr, nullptr, true);
+            arrowFuncExpr->SetStart(startLoc);
+            return arrowFuncExpr;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT: {
+            if (Extension() == ScriptExtension::TS) {
+                return nullptr;
+            }
+
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN: {
+            if (Extension() != ScriptExtension::TS) {
+                return nullptr;
+            }
+
+            const auto savedPos = lexer_->Save();
+
+            typeParamDecl = ParseTsTypeParameterDeclaration(false);
+            if (!typeParamDecl) {
+                lexer_->Rewind(savedPos);
+                return nullptr;
+            }
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+                ThrowSyntaxError("'(' expected");
+            }
+
+            [[fallthrough]];
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS: {
+            ir::CallExpression *callExpression = ParseCallExpression(*returnExpression, false, true);
+
+            ir::Expression *returnTypeAnnotation = nullptr;
+            if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+                lexer_->NextToken();  // eat ':'
+                TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+                returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+            }
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_ARROW) {
+                ir::ArrowFunctionExpression *arrowFuncExpr =
+                    ParseArrowFunctionExpression(callExpression, typeParamDecl, returnTypeAnnotation, true);
+                arrowFuncExpr->SetStart(startLoc);
+
+                return arrowFuncExpr;
+            }
+
+            if (Extension() == ScriptExtension::TS && (returnTypeAnnotation || typeParamDecl)) {
+                ThrowSyntaxError("'=>' expected");
+            }
+
+            *returnExpression = callExpression;
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+
+    return nullptr;
+}
+
+bool ParserImpl::ParsePotentialTsGenericFunctionCall(ir::Expression **returnExpression,
+                                                     const lexer::SourcePosition &startLoc, bool ignoreCallExpression)
+{
+    if (Extension() != ScriptExtension::TS || lexer_->Lookahead() == LEX_CHAR_LESS_THAN) {
+        return true;
+    }
+
+    const auto savedPos = lexer_->Save();
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT) {
+        lexer_->BackwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
+    }
+
+    ir::TSTypeParameterInstantiation *typeParams = ParseTsTypeParameterInstantiation(false);
+
+    if (!typeParams) {
+        lexer_->Rewind(savedPos);
+        return true;
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::EOS) {
+        ThrowSyntaxError("'(' or '`' expected");
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        if (!ignoreCallExpression) {
+            *returnExpression = ParseCallExpression(*returnExpression, false);
+            (*returnExpression)->AsCallExpression()->SetTypeParams(typeParams);
+            return false;
+        }
+
+        return true;
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_BACK_TICK) {
+        ir::TemplateLiteral *propertyNode = ParseTemplateLiteral();
+        lexer::SourcePosition endLoc = propertyNode->End();
+
+        *returnExpression = AllocNode<ir::TaggedTemplateExpression>(*returnExpression, propertyNode, typeParams);
+        (*returnExpression)->SetRange({startLoc, endLoc});
+        return false;
+    }
+
+    lexer_->Rewind(savedPos);
+    return true;
+}
+
+ir::Expression *ParserImpl::ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
+                                                       bool ignoreCallExpression, bool *isChainExpression)
+{
+    ir::Expression *returnExpression = primaryExpr;
+
+    while (true) {
+        switch (lexer_->GetToken().Type()) {
+            case lexer::TokenType::PUNCTUATOR_QUESTION_DOT: {
+                *isChainExpression = true;
+                lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat ?.
+                returnExpression = ParseOptionalChain(returnExpression);
+                continue;
+            }
+            case lexer::TokenType::PUNCTUATOR_PERIOD: {
+                lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat period
+                bool isPrivate = false;
+
+                lexer::SourcePosition memberStart = lexer_->GetToken().Start();
+
+                if (Extension() == ScriptExtension::TS &&
+                    lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_HASH_MARK) {
+                    if (!(context_.Status() & ParserStatus::IN_CLASS_BODY)) {
+                        ThrowSyntaxError("Private identifiers are not allowed outside class bodies.");
+                    }
+                    isPrivate = true;
+                    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+                }
+
+                if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+                    ThrowSyntaxError("Expected an identifier");
+                }
+
+                auto *identNode = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+                identNode->SetRange(lexer_->GetToken().Loc());
+
+                ir::Expression *property = nullptr;
+                if (isPrivate) {
+                    property = AllocNode<ir::TSPrivateIdentifier>(identNode, nullptr, nullptr);
+                    property->SetRange({memberStart, identNode->End()});
+                } else {
+                    property = identNode;
+                }
+
+                const lexer::SourcePosition &startPos = returnExpression->Start();
+                returnExpression = AllocNode<ir::MemberExpression>(
+                    returnExpression, property, ir::MemberExpression::MemberExpressionKind::PROPERTY_ACCESS, false,
+                    false);
+                returnExpression->SetRange({startPos, property->End()});
+                lexer_->NextToken();
+                continue;
+            }
+            case lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET: {
+                if (context_.Status() & ParserStatus::IN_DECORATOR) {
+                    break;
+                }
+
+                lexer_->NextToken();  // eat '['
+                ir::Expression *propertyNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+                if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+                    ThrowSyntaxError("Unexpected token");
+                }
+
+                const lexer::SourcePosition &startPos = returnExpression->Start();
+                returnExpression = AllocNode<ir::MemberExpression>(
+                    returnExpression, propertyNode, ir::MemberExpression::MemberExpressionKind::ELEMENT_ACCESS, true,
+                    false);
+                returnExpression->SetRange({startPos, lexer_->GetToken().End()});
+                lexer_->NextToken();
+                continue;
+            }
+            case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT:
+            case lexer::TokenType::PUNCTUATOR_LESS_THAN: {
+                bool shouldBreak =
+                    ParsePotentialTsGenericFunctionCall(&returnExpression, startLoc, ignoreCallExpression);
+                if (shouldBreak) {
+                    break;
+                }
+
+                continue;
+            }
+            case lexer::TokenType::PUNCTUATOR_BACK_TICK: {
+                ir::TemplateLiteral *propertyNode = ParseTemplateLiteral();
+                lexer::SourcePosition endLoc = propertyNode->End();
+
+                returnExpression = AllocNode<ir::TaggedTemplateExpression>(returnExpression, propertyNode, nullptr);
+                returnExpression->SetRange({startLoc, endLoc});
+                continue;
+            }
+            case lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS: {
+                if (!ignoreCallExpression) {
+                    returnExpression = ParseCallExpression(returnExpression, false);
+                    continue;
+                }
+                break;
+            }
+            case lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK: {
+                if (Extension() != ScriptExtension::TS || !returnExpression || lexer_->GetToken().NewLine()) {
+                    break;
+                }
+
+                returnExpression = AllocNode<ir::TSNonNullExpression>(returnExpression);
+                returnExpression->SetRange({startLoc, lexer_->GetToken().End()});
+                lexer_->NextToken();
+                continue;
+            }
+            default: {
+                break;
+            }
+        }
+
+        break;
+    }
+
+    return returnExpression;
+}
+
+void ParserImpl::ValidateUpdateExpression(ir::Expression *returnExpression, bool isChainExpression)
+{
+    if ((!returnExpression->IsMemberExpression() && !returnExpression->IsIdentifier() &&
+         !returnExpression->IsTSNonNullExpression()) ||
+        isChainExpression) {
+        ThrowSyntaxError("Invalid left-hand side operator.");
+    }
+
+    if (returnExpression->IsIdentifier()) {
+        const util::StringView &returnExpressionStr = returnExpression->AsIdentifier()->Name();
+
+        if (returnExpressionStr.Is("eval")) {
+            ThrowSyntaxError("Assigning to 'eval' in strict mode is invalid");
+        }
+
+        if (returnExpressionStr.Is("arguments")) {
+            ThrowSyntaxError("Assigning to 'arguments' in strict mode is invalid");
+        }
+    }
+}
+
+ir::Expression *ParserImpl::ParseMemberExpression(bool ignoreCallExpression, ExpressionParseFlags flags)
+{
+    bool isAsync = lexer_->GetToken().IsAsyncModifier();
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    ir::Expression *returnExpression = ParsePrimaryExpression(flags);
+
+    if (lexer_->GetToken().NewLine() && returnExpression->IsArrowFunctionExpression()) {
+        return returnExpression;
+    }
+
+    if (isAsync && !lexer_->GetToken().NewLine()) {
+        ir::ArrowFunctionExpression *arrow = ParsePotentialArrowExpression(&returnExpression, startLoc);
+
+        if (arrow) {
+            return arrow;
+        }
+    }
+
+    bool isChainExpression = false;
+    returnExpression = ParsePostPrimaryExpression(returnExpression, startLoc, ignoreCallExpression, &isChainExpression);
+
+    if (!lexer_->GetToken().NewLine() && lexer::Token::IsUpdateToken(lexer_->GetToken().Type())) {
+        lexer::SourcePosition start = returnExpression->Start();
+
+        ValidateUpdateExpression(returnExpression, isChainExpression);
+
+        returnExpression = AllocNode<ir::UpdateExpression>(returnExpression, lexer_->GetToken().Type(), false);
+
+        returnExpression->SetRange({start, lexer_->GetToken().End()});
+        lexer_->NextToken();
+    }
+
+    if (isChainExpression) {
+        lexer::SourcePosition endLoc = returnExpression->End();
+        returnExpression = AllocNode<ir::ChainExpression>(returnExpression);
+        returnExpression->SetRange({startLoc, endLoc});
+    }
+
+    return returnExpression;
+}
+
+void ParserImpl::ParsePotentialTsFunctionParameter(ExpressionParseFlags flags, ir::Expression *returnNode,
+                                                   bool isDeclare)
+{
+    if (Extension() != ScriptExtension::TS || !(context_.Status() & ParserStatus::FUNCTION_PARAM)) {
+        return;
+    }
+
+    bool isOptional = false;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
+        if (flags & ExpressionParseFlags::IN_REST) {
+            ThrowSyntaxError("A rest parameter cannot be optional");
+        }
+
+        if (!isDeclare && (returnNode->IsArrayPattern() || returnNode->IsObjectPattern())) {
+            ThrowSyntaxError(
+                "A binding pattern parameter cannot be optional in an "
+                "implementation signature");
+        }
+
+        ASSERT(returnNode->IsIdentifier() || returnNode->IsObjectPattern() || returnNode->IsArrayPattern());
+        if (returnNode->IsIdentifier()) {
+            returnNode->AsIdentifier()->SetOptional(true);
+        } else if (returnNode->IsObjectPattern()) {
+            returnNode->AsObjectPattern()->SetOptional(true);
+        } else if (returnNode->IsArrayPattern()) {
+            returnNode->AsArrayPattern()->SetOptional(true);
+        }
+
+        isOptional = true;
+        lexer_->NextToken();  // eat '?'
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+        lexer_->NextToken();  // eat ':'
+        TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+        returnNode->SetTsTypeAnnotation(ParseTsTypeAnnotation(&options));
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        return;
+    }
+
+    if (flags & ExpressionParseFlags::IN_REST) {
+        ThrowSyntaxError("A rest parameter cannot have an initializer");
+    }
+
+    if (returnNode->IsIdentifier() && isOptional) {
+        ThrowSyntaxError("Parameter cannot have question mark and initializer");
+    }
+}
+
+ir::Expression *ParserImpl::ParsePatternElement(ExpressionParseFlags flags, bool allowDefault, bool isDeclare)
+{
+    ir::Expression *returnNode = nullptr;
+    ArenaVector<ir::Decorator *> decorators(Allocator()->Adapter());
+
+    if (context_.Status() & ParserStatus::IN_METHOD_DEFINITION) {
+        decorators = ParseDecorators();
+    }
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET: {
+            returnNode = ParseArrayExpression(ExpressionParseFlags::MUST_BE_PATTERN);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD: {
+            if (flags & ExpressionParseFlags::IN_REST) {
+                ThrowSyntaxError("Unexpected token");
+            }
+
+            returnNode = ParseSpreadElement(ExpressionParseFlags::MUST_BE_PATTERN);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_BRACE: {
+            returnNode =
+                ParseObjectExpression(ExpressionParseFlags::MUST_BE_PATTERN | ExpressionParseFlags::OBJECT_PATTERN);
+            break;
+        }
+        case lexer::TokenType::LITERAL_IDENT: {
+            returnNode = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), std::move(decorators));
+            returnNode->AsIdentifier()->SetReference();
+
+            if (returnNode->AsIdentifier()->Decorators().empty()) {
+                returnNode->SetRange(lexer_->GetToken().Loc());
+            } else {
+                returnNode->SetRange(
+                    {returnNode->AsIdentifier()->Decorators().front()->Start(), lexer_->GetToken().End()});
+            }
+            lexer_->NextToken();
+            break;
+        }
+        default: {
+            ThrowSyntaxError("Unexpected token, expected an identifier.");
+        }
+    }
+
+    ParsePotentialTsFunctionParameter(flags, returnNode, isDeclare);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        return returnNode;
+    }
+
+    if (flags & ExpressionParseFlags::IN_REST) {
+        ThrowSyntaxError("Unexpected token, expected ')'");
+    }
+
+    if (!allowDefault) {
+        ThrowSyntaxError("Invalid destructuring assignment target");
+    }
+
+    lexer_->NextToken();
+
+    if ((context_.Status() & ParserStatus::GENERATOR_FUNCTION) &&
+        lexer_->GetToken().Type() == lexer::TokenType::KEYW_YIELD) {
+        ThrowSyntaxError("Yield is not allowed in generator parameters");
+    }
+
+    ir::Expression *rightNode = ParseExpression();
+
+    auto *assignmentExpression = AllocNode<ir::AssignmentExpression>(
+        ir::AstNodeType::ASSIGNMENT_PATTERN, returnNode, rightNode, lexer::TokenType::PUNCTUATOR_SUBSTITUTION);
+    assignmentExpression->SetRange({returnNode->Start(), rightNode->End()});
+
+    return assignmentExpression;
+}
+
+void ParserImpl::CheckPropertyKeyAsycModifier(ParserStatus *methodStatus)
+{
+    const auto asyncPos = lexer_->Save();
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        if (lexer_->GetToken().NewLine()) {
+            ThrowSyntaxError(
+                "Async methods cannot have a line terminator between "
+                "'async' and the property name");
+        }
+
+        *methodStatus |= ParserStatus::ASYNC_FUNCTION;
+    } else {
+        lexer_->Rewind(asyncPos);
+    }
+}
+
+static bool IsAccessorDelimiter(char32_t cp)
+{
+    switch (cp) {
+        case LEX_CHAR_LEFT_PAREN:
+        case LEX_CHAR_COLON:
+        case LEX_CHAR_COMMA:
+        case LEX_CHAR_RIGHT_BRACE: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+
+static bool IsShorthandDelimiter(char32_t cp)
+{
+    switch (cp) {
+        case LEX_CHAR_EQUALS:
+        case LEX_CHAR_COMMA:
+        case LEX_CHAR_RIGHT_BRACE: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+
+void ParserImpl::ValidateAccessor(ExpressionParseFlags flags, lexer::TokenFlags currentTokenFlags)
+{
+    if (flags & ExpressionParseFlags::MUST_BE_PATTERN) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    if (currentTokenFlags & lexer::TokenFlags::HAS_ESCAPE) {
+        ThrowSyntaxError("Keyword must not contain escaped characters");
+    }
+}
+
+ir::Property *ParserImpl::ParseShorthandProperty(const lexer::LexerPosition *startPos)
+{
+    char32_t nextCp = lexer_->Lookahead();
+    lexer::TokenType keywordType = lexer_->GetToken().KeywordType();
+
+    /* Rewind the lexer to the beginning of the ident to repase as common
+     * identifier */
+    lexer_->Rewind(*startPos);
+    lexer_->NextToken();
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Expected an identifier");
+    }
+
+    if (lexer_->GetToken().KeywordType() >= lexer::TokenType::KEYW_PRIVATE &&
+        lexer_->GetToken().KeywordType() <= lexer::TokenType::KEYW_DECLARE) {
+        ThrowSyntaxError(" Unexpected reserved word", lexer_->GetToken().Start());
+    }
+
+    const util::StringView &ident = lexer_->GetToken().Ident();
+
+    auto *key = AllocNode<ir::Identifier>(ident, Allocator());
+    key->SetRange(lexer_->GetToken().Loc());
+
+    ir::Expression *value = AllocNode<ir::Identifier>(ident, Allocator());
+    value->AsIdentifier()->SetReference();
+    value->SetRange(lexer_->GetToken().Loc());
+
+    lexer::SourcePosition end;
+
+    if (nextCp == LEX_CHAR_EQUALS) {
+        if (keywordType == lexer::TokenType::KEYW_EVAL) {
+            ThrowSyntaxError("eval can't be defined or assigned to in strict mode code");
+        }
+
+        lexer_->NextToken();  // substitution
+        lexer_->NextToken();  // eat substitution
+
+        ir::Expression *rightNode = ParseExpression();
+
+        auto *assignmentExpression = AllocNode<ir::AssignmentExpression>(
+            ir::AstNodeType::ASSIGNMENT_PATTERN, value, rightNode, lexer::TokenType::PUNCTUATOR_SUBSTITUTION);
+        assignmentExpression->SetRange({value->Start(), rightNode->End()});
+        end = rightNode->End();
+        value = assignmentExpression;
+    } else {
+        end = lexer_->GetToken().End();
+        lexer_->NextToken();
+    }
+
+    auto *returnProperty = AllocNode<ir::Property>(key, value);
+    returnProperty->SetRange({start, end});
+
+    return returnProperty;
+}
+
+bool ParserImpl::ParsePropertyModifiers(ExpressionParseFlags flags, ir::PropertyKind *propertyKind,
+                                        ParserStatus *methodStatus)
+{
+    if (lexer_->GetToken().IsAsyncModifier()) {
+        CheckPropertyKeyAsycModifier(methodStatus);
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MULTIPLY) {
+        if (flags & ExpressionParseFlags::MUST_BE_PATTERN) {
+            ThrowSyntaxError("Unexpected token");
+        }
+
+        lexer_->NextToken();
+        *methodStatus |= ParserStatus::GENERATOR_FUNCTION;
+    }
+
+    lexer::TokenFlags currentTokenFlags = lexer_->GetToken().Flags();
+    char32_t nextCp = lexer_->Lookahead();
+    lexer::TokenType keywordType = lexer_->GetToken().KeywordType();
+    // Parse getter property
+    if (keywordType == lexer::TokenType::KEYW_GET && !IsAccessorDelimiter(nextCp)) {
+        ValidateAccessor(flags, currentTokenFlags);
+
+        *propertyKind = ir::PropertyKind::GET;
+        lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+
+        return false;
+    }
+
+    // Parse setter property
+    if (keywordType == lexer::TokenType::KEYW_SET && !IsAccessorDelimiter(nextCp)) {
+        ValidateAccessor(flags, currentTokenFlags);
+
+        *propertyKind = ir::PropertyKind::SET;
+        lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+
+        return false;
+    }
+
+    // Parse shorthand property or assignment pattern
+    return (IsShorthandDelimiter(nextCp) && !(*methodStatus & ParserStatus::ASYNC_FUNCTION));
+}
+
+void ParserImpl::ParseGeneratorPropertyModifier(ExpressionParseFlags flags, ParserStatus *methodStatus)
+{
+    if (flags & ExpressionParseFlags::MUST_BE_PATTERN) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+    *methodStatus |= ParserStatus::GENERATOR_FUNCTION;
+}
+
+ir::Expression *ParserImpl::ParsePropertyKey(ExpressionParseFlags flags)
+{
+    ir::Expression *key = nullptr;
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::LITERAL_IDENT: {
+            const util::StringView &ident = lexer_->GetToken().Ident();
+            key = AllocNode<ir::Identifier>(ident, Allocator());
+            key->SetRange(lexer_->GetToken().Loc());
+            break;
+        }
+        case lexer::TokenType::LITERAL_STRING: {
+            const util::StringView &string = lexer_->GetToken().String();
+            key = AllocNode<ir::StringLiteral>(string);
+            key->SetRange(lexer_->GetToken().Loc());
+            break;
+        }
+        case lexer::TokenType::LITERAL_NUMBER: {
+            if (lexer_->GetToken().Flags() & lexer::TokenFlags::NUMBER_BIGINT) {
+                key = AllocNode<ir::BigIntLiteral>(lexer_->GetToken().BigInt());
+            } else {
+                key = AllocNode<ir::NumberLiteral>(lexer_->GetToken().Number(), lexer_->GetToken().String());
+            }
+
+            key->SetRange(lexer_->GetToken().Loc());
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET: {
+            lexer_->NextToken();  // eat left square bracket
+
+            key = ParseExpression(flags | ExpressionParseFlags::ACCEPT_COMMA);
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+                ThrowSyntaxError("Unexpected token, expected ']'");
+            }
+            break;
+        }
+        default: {
+            ThrowSyntaxError("Unexpected token in property key");
+        }
+    }
+
+    lexer_->NextToken();
+    return key;
+}
+
+ir::Expression *ParserImpl::ParsePropertyValue(const ir::PropertyKind *propertyKind, const ParserStatus *methodStatus,
+                                               ExpressionParseFlags flags)
+{
+    bool isMethod = *methodStatus & ParserStatus::FUNCTION;
+    bool inPattern = (flags & ExpressionParseFlags::MUST_BE_PATTERN);
+
+    if (!isMethod && !ir::Property::IsAccessorKind(*propertyKind)) {
+        // If the actual property is not getter/setter nor method, the following
+        // token must be ':'
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON) {
+            ThrowSyntaxError("Unexpected token, expected ':'");
+        }
+
+        lexer_->NextToken();  // eat colon
+
+        if (!inPattern) {
+            return ParseExpression(flags);
+        }
+
+        return ParsePatternElement();
+    }
+
+    if (inPattern) {
+        ThrowSyntaxError("Object pattern can't contain methods");
+    }
+
+    ir::ScriptFunction *methodDefinitonNode =
+        ParseFunction(*methodStatus | ParserStatus::FUNCTION | ParserStatus::ALLOW_SUPER);
+    methodDefinitonNode->AddFlag(ir::ScriptFunctionFlags::METHOD);
+
+    size_t paramsSize = methodDefinitonNode->Params().size();
+
+    auto *value = AllocNode<ir::FunctionExpression>(methodDefinitonNode);
+    value->SetRange(methodDefinitonNode->Range());
+
+    if (*propertyKind == ir::PropertyKind::SET && paramsSize != 1) {
+        ThrowSyntaxError("Setter must have exactly one formal parameter");
+    }
+
+    if (*propertyKind == ir::PropertyKind::GET && paramsSize != 0) {
+        ThrowSyntaxError("Getter must not have formal parameters");
+    }
+
+    return value;
+}
+
+ir::Expression *ParserImpl::ParsePropertyDefinition(ExpressionParseFlags flags)
+{
+    ir::PropertyKind propertyKind = ir::PropertyKind::INIT;
+    ParserStatus methodStatus = ParserStatus::NO_OPTS;
+
+    const auto startPos = lexer_->Save();
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD) {
+        return ParseSpreadElement(flags);
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT) {
+        if (ParsePropertyModifiers(flags, &propertyKind, &methodStatus)) {
+            return ParseShorthandProperty(&startPos);
+        }
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MULTIPLY) {
+        ParseGeneratorPropertyModifier(flags, &methodStatus);
+    }
+
+    bool isComputed = lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET;
+    ir::Expression *key = ParsePropertyKey(flags);
+
+    // Parse method property
+    if ((lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS ||
+         lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) &&
+        !ir::Property::IsAccessorKind(propertyKind)) {
+        methodStatus |= ParserStatus::FUNCTION | ParserStatus::ALLOW_SUPER;
+        propertyKind = ir::PropertyKind::INIT;
+    } else if (methodStatus & (ParserStatus::GENERATOR_FUNCTION | ParserStatus::ASYNC_FUNCTION)) {
+        ThrowSyntaxError("Unexpected identifier");
+    }
+
+    ir::Expression *value = ParsePropertyValue(&propertyKind, &methodStatus, flags);
+    lexer::SourcePosition end = value->End();
+
+    ASSERT(key);
+    ASSERT(value);
+
+    auto *returnProperty =
+        AllocNode<ir::Property>(propertyKind, key, value, methodStatus != ParserStatus::NO_OPTS, isComputed);
+    returnProperty->SetRange({start, end});
+
+    return returnProperty;
+}
+
+bool ParserImpl::ParsePropertyEnd()
+{
+    // Property definiton must end with ',' or '}' otherwise we throw SyntaxError
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ThrowSyntaxError("Unexpected token, expected ',' or '}'");
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA &&
+        lexer_->Lookahead() == LEX_CHAR_RIGHT_BRACE) {
+        lexer_->NextToken();
+        return true;
+    }
+
+    return false;
+}
+
+ir::ObjectExpression *ParserImpl::ParseObjectExpression(ExpressionParseFlags flags)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE);
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+    ArenaVector<ir::Expression *> properties(Allocator()->Adapter());
+    bool trailingComma = false;
+    bool inPattern = (flags & ExpressionParseFlags::MUST_BE_PATTERN);
+
+    if (lexer_->Lookahead() == LEX_CHAR_RIGHT_BRACE) {
+        lexer_->NextToken();
+    }
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ir::Expression *property = ParsePropertyDefinition(flags | ExpressionParseFlags::POTENTIALLY_IN_PATTERN);
+        properties.push_back(property);
+        trailingComma = ParsePropertyEnd();
+    }
+
+    auto nodeType = inPattern ? ir::AstNodeType::OBJECT_PATTERN : ir::AstNodeType::OBJECT_EXPRESSION;
+    auto *objectExpression = AllocNode<ir::ObjectExpression>(nodeType, std::move(properties), trailingComma);
+    objectExpression->SetRange({start, lexer_->GetToken().End()});
+    lexer_->NextToken();
+
+    if (inPattern) {
+        objectExpression->SetDeclaration();
+    }
+
+    if (Extension() == ScriptExtension::TS && (flags & ExpressionParseFlags::ALLOW_TS_PARAM_TOKEN) &&
+        lexer::Token::IsTsParamToken(lexer_->GetToken().Type())) {
+        context_.Status() |= ParserStatus::FUNCTION_PARAM;
+        ParsePotentialTsFunctionParameter(ExpressionParseFlags::NO_OPTS, objectExpression);
+    }
+
+    if (!(flags & ExpressionParseFlags::POTENTIALLY_IN_PATTERN)) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION &&
+            !objectExpression->ConvertibleToObjectPattern()) {
+            ThrowSyntaxError("Invalid left-hand side in array destructuring pattern", objectExpression->Start());
+        } else if (!inPattern && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+            ir::ValidationInfo info = objectExpression->ValidateExpression();
+            if (info.Fail()) {
+                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+            }
+        }
+    }
+
+    return objectExpression;
+}
+
+ir::SequenceExpression *ParserImpl::ParseSequenceExpression(ir::Expression *startExpr, bool acceptRest,
+                                                            bool acceptTsParam)
+{
+    lexer::SourcePosition start = startExpr->Start();
+
+    ArenaVector<ir::Expression *> sequence(Allocator()->Adapter());
+    sequence.push_back(startExpr);
+
+    while (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+        lexer_->NextToken();
+
+        if (acceptRest && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD) {
+            ir::SpreadElement *expr = ParseSpreadElement(ExpressionParseFlags::MUST_BE_PATTERN);
+            sequence.push_back(expr);
+            break;
+        }
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS && lexer_->CheckArrow()) {
+            break;
+        }
+
+        sequence.push_back(ParseExpression(acceptTsParam ? ExpressionParseFlags::ALLOW_TS_PARAM_TOKEN
+                                                         : ExpressionParseFlags::NO_OPTS));
+    }
+
+    lexer::SourcePosition end = sequence.back()->End();
+    auto *sequenceNode = AllocNode<ir::SequenceExpression>(std::move(sequence));
+    sequenceNode->SetRange({start, end});
+
+    return sequenceNode;
+}
+
+ir::Expression *ParserImpl::ParseUnaryOrPrefixUpdateExpression(ExpressionParseFlags flags)
+{
+    if (!lexer_->GetToken().IsUnary()) {
+        return ParseLeftHandSideExpression(flags);
+    }
+
+    lexer::TokenType operatorType = lexer_->GetToken().Type();
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+    lexer_->NextToken();
+
+    ir::Expression *argument =
+        lexer_->GetToken().IsUnary() ? ParseUnaryOrPrefixUpdateExpression() : ParseLeftHandSideExpression();
+
+    if (lexer::Token::IsUpdateToken(operatorType)) {
+        if (!argument->IsIdentifier() && !argument->IsMemberExpression() && !argument->IsTSNonNullExpression()) {
+            ThrowSyntaxError("Invalid left-hand side in prefix operation");
+        }
+
+        if (argument->IsIdentifier()) {
+            const util::StringView &argumentStr = argument->AsIdentifier()->Name();
+
+            if (argumentStr.Is("eval")) {
+                ThrowSyntaxError("Assigning to 'eval' in strict mode is invalid");
+            } else if (argumentStr.Is("arguments")) {
+                ThrowSyntaxError("Assigning to 'arguments' in strict mode is invalid");
+            }
+        }
+    }
+
+    if (operatorType == lexer::TokenType::KEYW_DELETE && argument->IsIdentifier()) {
+        ThrowSyntaxError("Deleting local variable in strict mode");
+    }
+
+    lexer::SourcePosition end = argument->End();
+
+    ir::Expression *returnExpr = nullptr;
+
+    if (lexer::Token::IsUpdateToken(operatorType)) {
+        returnExpr = AllocNode<ir::UpdateExpression>(argument, operatorType, true);
+    } else if (operatorType == lexer::TokenType::KEYW_AWAIT) {
+        returnExpr = AllocNode<ir::AwaitExpression>(argument);
+    } else {
+        returnExpr = AllocNode<ir::UnaryExpression>(argument, operatorType);
+    }
+
+    returnExpr->SetRange({start, end});
+
+    return returnExpr;
+}
+
+ir::Expression *ParserImpl::ParseImportExpression()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();  // eat import
+
+    // parse import.Meta
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+        if (!context_.IsModule()) {
+            ThrowSyntaxError("'import.Meta' may appear only with 'sourceType: module'");
+        }
+
+        lexer_->NextToken();  // eat dot
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT ||
+            lexer_->GetToken().KeywordType() != lexer::TokenType::KEYW_META) {
+            ThrowSyntaxError("The only valid meta property for import is import.Meta");
+        }
+
+        auto *metaProperty = AllocNode<ir::MetaProperty>(ir::MetaProperty::MetaPropertyKind::IMPORT_META);
+        metaProperty->SetRange({startLoc, endLoc});
+
+        lexer_->NextToken();
+        return metaProperty;
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    lexer_->NextToken();  // eat left parentheses
+
+    ir::Expression *source = ParseExpression();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    auto *importExpression = AllocNode<ir::ImportExpression>(source);
+    importExpression->SetRange({startLoc, lexer_->GetToken().End()});
+
+    lexer_->NextToken();  // eat right paren
+    return importExpression;
+}
+
+ir::FunctionExpression *ParserImpl::ParseFunctionExpression(ParserStatus newStatus)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    ir::Identifier *ident = nullptr;
+
+    if (!(newStatus & ParserStatus::ARROW_FUNCTION)) {
+        ParserStatus savedStatus = context_.Status();
+
+        if (newStatus & ParserStatus::ASYNC_FUNCTION) {
+            context_.Status() |= (ParserStatus::DISALLOW_AWAIT | ParserStatus::ASYNC_FUNCTION);
+        }
+
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MULTIPLY) {
+            newStatus |= ParserStatus::GENERATOR_FUNCTION;
+            lexer_->NextToken();
+        }
+
+        if ((Extension() == ScriptExtension::JS &&
+             lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) ||
+            (Extension() == ScriptExtension::TS &&
+             lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS &&
+             lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LESS_THAN)) {
+            if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+                ThrowSyntaxError("Expected an identifier.");
+            }
+
+            if (lexer_->GetToken().KeywordType() >= lexer::TokenType::KEYW_ARGUMENTS) {
+                ThrowSyntaxError("Unexpected reserved word in strict mode.");
+            }
+
+            ident = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+            ident->SetRange(lexer_->GetToken().Loc());
+            lexer_->NextToken();
+        }
+
+        context_.Status() = savedStatus;
+    }
+
+    ir::ScriptFunction *functionNode = ParseFunction(newStatus);
+    functionNode->SetStart(startLoc);
+
+    if (ident) {
+        auto *funcParamScope = functionNode->Scope()->ParamScope();
+        funcParamScope->BindName(Allocator(), ident->Name());
+        functionNode->SetIdent(ident);
+    }
+
+    auto *funcExpr = AllocNode<ir::FunctionExpression>(functionNode);
+    funcExpr->SetRange(functionNode->Range());
+
+    return funcExpr;
+}
+
+}  // namespace panda::es2panda::parser
diff --git a/es2panda/parser/parserFlags.h b/es2panda/parser/parserFlags.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb64a73ee2ac096b374ece7d2dfbfa9bbf0b3e0e
--- /dev/null
+++ b/es2panda/parser/parserFlags.h
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_PARSER_FLAGS_H
+#define ES2PANDA_PARSER_PARSER_FLAGS_H
+
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::parser {
+
+enum class LexicalScopeType {
+    BLOCK,
+    STRICT_BLOCK,
+    CATCH,
+    FUNCTION_PARAM,
+    TS_TYPE_LITERAL,
+};
+
+DEFINE_BITOPS(LexicalScopeType)
+
+enum class VariableParsingFlags {
+    NO_OPTS = 0,
+    NO_SKIP_VAR_KIND = (1 << 0),
+    ACCEPT_CONST_NO_INIT = (1 << 1),
+    DISALLOW_INIT = (1 << 2),
+    VAR = (1 << 3),
+    LET = (1 << 4),
+    CONST = (1 << 5),
+    STOP_AT_IN = (1 << 6),
+};
+
+DEFINE_BITOPS(VariableParsingFlags)
+
+enum class ExpressionParseFlags {
+    NO_OPTS = 0,
+    ACCEPT_COMMA = 1 << 0,
+    ACCEPT_REST = 1 << 1,
+    EXP_DISALLOW_AS = 1 << 2,
+    DISALLOW_ASSIGNMENT = 1 << 3,
+    DISALLOW_YIELD = 1 << 4,
+    STOP_AT_IN = 1 << 5,
+    ALLOW_TS_PARAM_TOKEN = 1 << 6,
+    MUST_BE_PATTERN = 1 << 7,
+    POTENTIALLY_IN_PATTERN = 1 << 8,
+    OBJECT_PATTERN = 1 << 9,
+    IN_REST = 1 << 10,
+};
+
+DEFINE_BITOPS(ExpressionParseFlags)
+
+enum class StatementParsingFlags {
+    NONE = 0,
+    ALLOW_LEXICAL = 1 << 0,
+    GLOBAL = 1 << 1,
+    IF_ELSE = 1 << 2,
+    LABELLED = 1 << 3,
+
+    STMT_LEXICAL_SCOPE_NEEDED = IF_ELSE | LABELLED,
+    STMT_GLOBAL_LEXICAL = GLOBAL | ALLOW_LEXICAL,
+};
+
+DEFINE_BITOPS(StatementParsingFlags)
+
+enum class ForStatementKind {
+    UPDATE,
+    IN,
+    OF,
+};
+
+}  // namespace panda::es2panda::parser
+
+#endif
diff --git a/es2panda/parser/parserImpl.cpp b/es2panda/parser/parserImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ecfc77b84dcbe26126be64ed45012ace09a8a34
--- /dev/null
+++ b/es2panda/parser/parserImpl.cpp
@@ -0,0 +1,3307 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "parserImpl.h"
+
+#include <binder/scope.h>
+#include <binder/tsBinding.h>
+#include <ir/astDump.h>
+#include <ir/astNode.h>
+#include <ir/base/classDefinition.h>
+#include <ir/base/classProperty.h>
+#include <ir/base/decorator.h>
+#include <ir/base/methodDefinition.h>
+#include <ir/base/property.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expression.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/callExpression.h>
+#include <ir/expressions/functionExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/bigIntLiteral.h>
+#include <ir/expressions/literals/booleanLiteral.h>
+#include <ir/expressions/literals/nullLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/expressions/superExpression.h>
+#include <ir/module/exportDefaultDeclaration.h>
+#include <ir/module/exportNamedDeclaration.h>
+#include <ir/module/exportSpecifier.h>
+#include <ir/statements/blockStatement.h>
+#include <ir/statements/emptyStatement.h>
+#include <ir/statements/expressionStatement.h>
+#include <ir/statements/functionDeclaration.h>
+#include <ir/ts/tsAnyKeyword.h>
+#include <ir/ts/tsArrayType.h>
+#include <ir/ts/tsBigintKeyword.h>
+#include <ir/ts/tsBooleanKeyword.h>
+#include <ir/ts/tsClassImplements.h>
+#include <ir/ts/tsConditionalType.h>
+#include <ir/ts/tsConstructorType.h>
+#include <ir/ts/tsEnumDeclaration.h>
+#include <ir/ts/tsEnumMember.h>
+#include <ir/ts/tsFunctionType.h>
+#include <ir/ts/tsImportType.h>
+#include <ir/ts/tsIndexSignature.h>
+#include <ir/ts/tsIndexedAccessType.h>
+#include <ir/ts/tsInferType.h>
+#include <ir/ts/tsIntersectionType.h>
+#include <ir/ts/tsLiteralType.h>
+#include <ir/ts/tsMappedType.h>
+#include <ir/ts/tsMethodSignature.h>
+#include <ir/ts/tsNamedTupleMember.h>
+#include <ir/ts/tsNeverKeyword.h>
+#include <ir/ts/tsNullKeyword.h>
+#include <ir/ts/tsNumberKeyword.h>
+#include <ir/ts/tsObjectKeyword.h>
+#include <ir/ts/tsParameterProperty.h>
+#include <ir/ts/tsParenthesizedType.h>
+#include <ir/ts/tsPrivateIdentifier.h>
+#include <ir/ts/tsPropertySignature.h>
+#include <ir/ts/tsQualifiedName.h>
+#include <ir/ts/tsSignatureDeclaration.h>
+#include <ir/ts/tsStringKeyword.h>
+#include <ir/ts/tsThisType.h>
+#include <ir/ts/tsTupleType.h>
+#include <ir/ts/tsTypeLiteral.h>
+#include <ir/ts/tsTypeOperator.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+#include <ir/ts/tsTypePredicate.h>
+#include <ir/ts/tsTypeQuery.h>
+#include <ir/ts/tsTypeReference.h>
+#include <ir/ts/tsUndefinedKeyword.h>
+#include <ir/ts/tsUnionType.h>
+#include <ir/ts/tsUnknownKeyword.h>
+#include <ir/ts/tsVoidKeyword.h>
+#include <lexer/lexer.h>
+#include <lexer/token/letters.h>
+#include <lexer/token/sourceLocation.h>
+#include <mem/pool_manager.h>
+
+namespace panda::es2panda::parser {
+
+ParserImpl::ParserImpl(ScriptExtension extension) : program_(extension), context_(&program_) {}
+
+std::unique_ptr<lexer::Lexer> ParserImpl::InitLexer(const std::string &fileName, const std::string &source)
+{
+    program_.SetSource(source, fileName);
+    auto lexer = std::make_unique<lexer::Lexer>(&context_);
+    lexer_ = lexer.get();
+
+    return lexer;
+}
+
+Program ParserImpl::ParseScript(const std::string &fileName, const std::string &source)
+{
+    auto lexer = InitLexer(fileName, source);
+
+    ParseProgram(ScriptKind::SCRIPT);
+    return std::move(program_);
+}
+
+Program ParserImpl::ParseModule(const std::string &fileName, const std::string &source)
+{
+    auto lexer = InitLexer(fileName, source);
+
+    context_.Status() |= (ParserStatus::MODULE);
+    ParseProgram(ScriptKind::MODULE);
+
+    if (!Binder()->TopScope()->AsModuleScope()->ExportAnalysis()) {
+        ThrowSyntaxError("Invalid exported binding");
+    }
+
+    return std::move(program_);
+}
+
+void ParserImpl::ParseProgram(ScriptKind kind)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+    program_.SetKind(kind);
+
+    auto statements = ParseStatementList(StatementParsingFlags::STMT_GLOBAL_LEXICAL);
+
+    auto *blockStmt = AllocNode<ir::BlockStatement>(Binder()->GetScope(), std::move(statements));
+    Binder()->GetScope()->BindNode(blockStmt);
+    blockStmt->SetRange({startLoc, lexer_->GetToken().End()});
+
+    program_.SetAst(blockStmt);
+    Binder()->IdentifierAnalysis();
+}
+
+/*
+ * Definitions of private methods
+ */
+ExpressionParseFlags ParserImpl::CarryExpressionParserFlag(ExpressionParseFlags origin, ExpressionParseFlags carry)
+{
+    return static_cast<ExpressionParseFlags>(origin & carry);
+}
+
+ExpressionParseFlags ParserImpl::CarryPatternFlags(ExpressionParseFlags flags)
+{
+    return CarryExpressionParserFlag(flags, ExpressionParseFlags::POTENTIALLY_IN_PATTERN |
+                                                ExpressionParseFlags::OBJECT_PATTERN);
+}
+
+bool ParserImpl::CurrentLiteralIsBasicType()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT ||
+           lexer_->GetToken().Type() == lexer::TokenType::KEYW_EXTENDS);
+
+    switch (lexer_->GetToken().KeywordType()) {
+        case lexer::TokenType::KEYW_ANY:
+        case lexer::TokenType::KEYW_BOOLEAN:
+        case lexer::TokenType::KEYW_NUMBER:
+        case lexer::TokenType::KEYW_STRING:
+        case lexer::TokenType::KEYW_UNKNOWN:
+        case lexer::TokenType::KEYW_UNDEFINED:
+        case lexer::TokenType::KEYW_NEVER:
+        case lexer::TokenType::KEYW_OBJECT:
+        case lexer::TokenType::KEYW_BIGINT: {
+            return true;
+        }
+        default: {
+            break;
+        }
+    }
+
+    return false;
+}
+bool ParserImpl::CurrentIsBasicType()
+{
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::PUNCTUATOR_MINUS:
+        case lexer::TokenType::LITERAL_NUMBER:
+        case lexer::TokenType::LITERAL_STRING:
+        case lexer::TokenType::LITERAL_FALSE:
+        case lexer::TokenType::LITERAL_TRUE:
+        case lexer::TokenType::LITERAL_NULL:
+        case lexer::TokenType::KEYW_VOID: {
+            return true;
+        }
+        case lexer::TokenType::LITERAL_IDENT: {
+            return CurrentLiteralIsBasicType();
+        }
+        default: {
+            break;
+        }
+    }
+
+    return false;
+}
+
+ir::TSTypeReference *ParserImpl::ParseTsConstExpression()
+{
+    auto *identRef = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    identRef->SetReference();
+    identRef->SetRange(lexer_->GetToken().Loc());
+
+    auto *typeReference = AllocNode<ir::TSTypeReference>(identRef, nullptr);
+    typeReference->SetRange(lexer_->GetToken().Loc());
+
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON &&
+        lexer_->GetToken().Type() != lexer::TokenType::EOS &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET &&
+        !(lexer_->GetToken().Flags() & lexer::TokenFlags::NEW_LINE)) {
+        ThrowSyntaxError("Unexpected token.");
+    }
+
+    return typeReference;
+}
+
+ir::Expression *ParserImpl::ParseTsIdentifierReference()
+{
+    if (CurrentLiteralIsBasicType() && lexer_->Lookahead() != LEX_CHAR_DOT) {
+        return ParseTsBasicType();
+    }
+
+    return ParseTsTypeReferenceOrQuery();
+}
+
+bool ParserImpl::IsStartOfMappedType() const
+{
+    auto pos = lexer_->Save();
+    lexer_->NextToken();
+    bool result = false;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MINUS ||
+        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PLUS) {
+        lexer_->NextToken();
+        result = lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_READONLY;
+        lexer_->Rewind(pos);
+        return result;
+    }
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_READONLY) {
+        lexer_->NextToken();
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET) {
+        lexer_->Rewind(pos);
+        return false;
+    }
+
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        lexer_->Rewind(pos);
+        return false;
+    }
+
+    lexer_->NextToken();
+
+    result = lexer_->GetToken().Type() == lexer::TokenType::KEYW_IN;
+
+    lexer_->Rewind(pos);
+    return result;
+}
+
+bool ParserImpl::IsStartOfTsTypePredicate() const
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT ||
+           lexer_->GetToken().Type() == lexer::TokenType::KEYW_THIS);
+
+    auto pos = lexer_->Save();
+    bool isAsserts = lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ASSERTS;
+    if (isAsserts) {
+        lexer_->NextToken();
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT &&
+        lexer_->GetToken().Type() != lexer::TokenType::KEYW_THIS) {
+        lexer_->Rewind(pos);
+        return false;
+    }
+
+    if (isAsserts) {
+        lexer_->Rewind(pos);
+        return true;
+    }
+
+    lexer_->NextToken();
+
+    bool result = lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_IS;
+    lexer_->Rewind(pos);
+    return result;
+}
+
+bool ParserImpl::IsStartOfAbstractConstructorType() const
+{
+    if (lexer_->GetToken().KeywordType() != lexer::TokenType::KEYW_ABSTRACT) {
+        return false;
+    }
+
+    lexer::LexerPosition pos = lexer_->Save();
+    lexer_->NextToken();  // eat 'abstract'
+    bool result = lexer_->GetToken().Type() == lexer::TokenType::KEYW_NEW;
+
+    lexer_->Rewind(pos);
+
+    return result;
+}
+
+ir::Expression *ParserImpl::ParseTsTypeLiteralOrTsMappedType(ir::Expression *typeAnnotation)
+{
+    if (typeAnnotation) {
+        return nullptr;
+    }
+
+    if (IsStartOfMappedType()) {
+        return ParseTsMappedType();
+    }
+
+    lexer::SourcePosition bodyStart = lexer_->GetToken().Start();
+    auto members = ParseTsTypeLiteralOrInterface();
+    lexer::SourcePosition bodyEnd = lexer_->GetToken().End();
+    lexer_->NextToken();
+
+    auto *literalType = AllocNode<ir::TSTypeLiteral>(std::move(members));
+    literalType->SetRange({bodyStart, bodyEnd});
+    return literalType;
+}
+
+ir::Expression *ParserImpl::ParseTsTypeReferenceOrTsTypePredicate(ir::Expression *typeAnnotation,
+                                                                  bool canBeTsTypePredicate)
+{
+    if (typeAnnotation) {
+        return nullptr;
+    }
+
+    if (canBeTsTypePredicate && IsStartOfTsTypePredicate()) {
+        return ParseTsTypePredicate();
+    }
+
+    return ParseTsTypeOperatorOrTypeReference();
+}
+
+ir::Expression *ParserImpl::ParseTsThisTypeOrTsTypePredicate(ir::Expression *typeAnnotation, bool canBeTsTypePredicate,
+                                                             bool throwError)
+{
+    if (typeAnnotation) {
+        return nullptr;
+    }
+
+    if (canBeTsTypePredicate && IsStartOfTsTypePredicate()) {
+        return ParseTsTypePredicate();
+    }
+
+    return ParseTsThisType(throwError);
+}
+
+ir::Expression *ParserImpl::ParseTsTypeAnnotationElement(ir::Expression *typeAnnotation,
+                                                         TypeAnnotationParsingOptions *options)
+{
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR: {
+            if (*options & (TypeAnnotationParsingOptions::IN_UNION | TypeAnnotationParsingOptions::IN_INTERSECTION)) {
+                break;
+            }
+
+            return ParseTsUnionType(typeAnnotation, *options & TypeAnnotationParsingOptions::RESTRICT_EXTENDS);
+        }
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND: {
+            if (*options & TypeAnnotationParsingOptions::IN_INTERSECTION) {
+                break;
+            }
+
+            return ParseTsIntersectionType(typeAnnotation, *options & TypeAnnotationParsingOptions::IN_UNION,
+                                           *options & TypeAnnotationParsingOptions::RESTRICT_EXTENDS);
+        }
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN:
+        case lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS:
+        case lexer::TokenType::KEYW_NEW: {
+            return ParseTsParenthesizedOrFunctionType(typeAnnotation,
+                                                      *options & TypeAnnotationParsingOptions::THROW_ERROR);
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET: {
+            if (typeAnnotation) {
+                if (lexer_->Lookahead() == LEX_CHAR_RIGHT_SQUARE) {
+                    return ParseTsArrayType(typeAnnotation);
+                }
+
+                return ParseTsIndexAccessType(typeAnnotation);
+            }
+
+            return ParseTsTupleType();
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_BRACE: {
+            return ParseTsTypeLiteralOrTsMappedType(typeAnnotation);
+        }
+        case lexer::TokenType::PUNCTUATOR_MINUS:
+        case lexer::TokenType::LITERAL_NUMBER:
+        case lexer::TokenType::LITERAL_STRING:
+        case lexer::TokenType::LITERAL_FALSE:
+        case lexer::TokenType::LITERAL_TRUE:
+        case lexer::TokenType::LITERAL_NULL:
+        case lexer::TokenType::KEYW_VOID: {
+            if (typeAnnotation) {
+                break;
+            }
+
+            return ParseTsBasicType();
+        }
+        case lexer::TokenType::KEYW_TYPEOF: {
+            if (typeAnnotation) {
+                break;
+            }
+
+            return ParseTsTypeReferenceOrQuery(true);
+        }
+        case lexer::TokenType::KEYW_IMPORT: {
+            if (typeAnnotation) {
+                break;
+            }
+
+            lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+            return ParseTsImportType(startLoc);
+        }
+        case lexer::TokenType::KEYW_CONST: {
+            if (!(*options & TypeAnnotationParsingOptions::ALLOW_CONST)) {
+                break;
+            }
+
+            *options &= ~TypeAnnotationParsingOptions::ALLOW_CONST;
+            return ParseTsConstExpression();
+        }
+        case lexer::TokenType::LITERAL_IDENT: {
+            if (IsStartOfAbstractConstructorType()) {
+                return ParseTsParenthesizedOrFunctionType(typeAnnotation,
+                                                          *options & TypeAnnotationParsingOptions::THROW_ERROR);
+            }
+
+            return ParseTsTypeReferenceOrTsTypePredicate(
+                typeAnnotation, *options & TypeAnnotationParsingOptions::CAN_BE_TS_TYPE_PREDICATE);
+        }
+        case lexer::TokenType::KEYW_EXTENDS: {
+            if (*options & (TypeAnnotationParsingOptions::IN_UNION | TypeAnnotationParsingOptions::IN_INTERSECTION)) {
+                break;
+            }
+
+            if (!typeAnnotation) {
+                return ParseTsIdentifierReference();
+            }
+
+            return ParseTsConditionalType(typeAnnotation, *options & TypeAnnotationParsingOptions::RESTRICT_EXTENDS);
+        }
+        case lexer::TokenType::KEYW_THIS: {
+            return ParseTsThisTypeOrTsTypePredicate(typeAnnotation,
+                                                    *options & TypeAnnotationParsingOptions::CAN_BE_TS_TYPE_PREDICATE,
+                                                    *options & TypeAnnotationParsingOptions::THROW_ERROR);
+        }
+        default: {
+            break;
+        }
+    }
+
+    if (!typeAnnotation && (*options & TypeAnnotationParsingOptions::THROW_ERROR)) {
+        ThrowSyntaxError("Type expected");
+    }
+
+    return nullptr;
+}
+
+ir::TSImportType *ParserImpl::ParseTsImportType(const lexer::SourcePosition &startLoc, bool isTypeof)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_IMPORT);
+
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        ThrowSyntaxError("'(' expected");
+    }
+
+    lexer_->NextToken();
+
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+    ir::Expression *param = ParseTsTypeAnnotation(&options);
+
+    if (!param->IsTSLiteralType() || !param->AsTSLiteralType()->Literal()->IsStringLiteral()) {
+        ThrowSyntaxError("String literal expected");
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("')' expected");
+    }
+
+    lexer_->NextToken();
+
+    ir::Expression *qualifier = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+            ThrowSyntaxError("Identifier expected");
+        }
+
+        qualifier = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        qualifier->SetRange(lexer_->GetToken().Loc());
+
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+            qualifier = ParseTsQualifiedReference(qualifier);
+        }
+    }
+
+    ir::TSTypeParameterInstantiation *typeParams = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT ||
+        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT) {
+            lexer_->BackwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
+        }
+
+        typeParams = ParseTsTypeParameterInstantiation();
+    }
+
+    auto *importType = AllocNode<ir::TSImportType>(param, typeParams, qualifier, isTypeof);
+
+    importType->SetRange({startLoc, lexer_->GetToken().End()});
+
+    return importType;
+}
+
+ir::Expression *ParserImpl::ParseTsThisType(bool throwError)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_THIS);
+
+    if (throwError && !(context_.Status() & ParserStatus::ALLOW_THIS_TYPE)) {
+        ThrowSyntaxError(
+            "A 'this' type is available only in a non-static member "
+            "of a class or interface.");
+    }
+
+    auto *returnType = AllocNode<ir::TSThisType>();
+    returnType->SetRange(lexer_->GetToken().Loc());
+
+    lexer_->NextToken();
+
+    return returnType;
+}
+
+ir::Expression *ParserImpl::ParseTsConditionalType(ir::Expression *checkType, bool restrictExtends)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_EXTENDS);
+    if (restrictExtends) {
+        ThrowSyntaxError("'?' expected.");
+    }
+
+    lexer::SourcePosition startLoc = checkType->Start();
+
+    lexer_->NextToken();  // eat 'extends'
+
+    ParserStatus savedStatus = context_.Status();
+    context_.Status() |= ParserStatus::IN_EXTENDS;
+
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::RESTRICT_EXTENDS;
+    auto *extendsType = ParseTsTypeAnnotation(&options);
+
+    context_.Status() = savedStatus;
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
+        ThrowSyntaxError("'?' expected.");
+    }
+
+    lexer_->NextToken();  // eat '?'
+
+    options &= ~TypeAnnotationParsingOptions::RESTRICT_EXTENDS;
+    auto *trueType = ParseTsTypeAnnotation(&options);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON) {
+        ThrowSyntaxError("':' expected.");
+    }
+
+    lexer_->NextToken();  // eat ':'
+
+    auto *falseType = ParseTsTypeAnnotation(&options);
+
+    lexer::SourcePosition endLoc = falseType->End();
+
+    auto *conditionalType = AllocNode<ir::TSConditionalType>(checkType, extendsType, trueType, falseType);
+
+    conditionalType->SetRange({startLoc, endLoc});
+
+    return conditionalType;
+}
+
+ir::Expression *ParserImpl::ParseTsTypeAnnotation(TypeAnnotationParsingOptions *options)
+{
+    ir::Expression *typeAnnotation = nullptr;
+
+    while (true) {
+        ir::Expression *element = ParseTsTypeAnnotationElement(typeAnnotation, options);
+
+        *options &= ~TypeAnnotationParsingOptions::CAN_BE_TS_TYPE_PREDICATE;
+
+        if (!element) {
+            break;
+        }
+
+        typeAnnotation = element;
+
+        if ((*options & TypeAnnotationParsingOptions::BREAK_AT_NEW_LINE) && lexer_->GetToken().NewLine()) {
+            break;
+        }
+    }
+
+    return typeAnnotation;
+}
+
+ir::Expression *ParserImpl::ParseTsTypeOperatorOrTypeReference()
+{
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_READONLY) {
+        lexer::SourcePosition typeOperatorStart = lexer_->GetToken().Start();
+        lexer_->NextToken();
+
+        ir::Expression *type = ParseTsTypeAnnotation(&options);
+
+        if (!type->IsTSArrayType() && !type->IsTSTupleType()) {
+            ThrowSyntaxError(
+                "'readonly' type modifier is only permitted on array "
+                "and tuple literal types.");
+        }
+
+        auto *typeOperator = AllocNode<ir::TSTypeOperator>(type, ir::TSOperatorType::READONLY);
+
+        typeOperator->SetRange({typeOperatorStart, type->End()});
+
+        return typeOperator;
+    }
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_KEYOF) {
+        lexer::SourcePosition typeOperatorStart = lexer_->GetToken().Start();
+        lexer_->NextToken();
+
+        ir::Expression *type = ParseTsTypeAnnotation(&options);
+
+        auto *typeOperator = AllocNode<ir::TSTypeOperator>(type, ir::TSOperatorType::KEYOF);
+
+        typeOperator->SetRange({typeOperatorStart, type->End()});
+
+        return typeOperator;
+    }
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_INFER) {
+        if (!(context_.Status() & ParserStatus::IN_EXTENDS)) {
+            ThrowSyntaxError(
+                "'infer' declarations are only permitted in the "
+                "'extends' clause of a conditional type.");
+        }
+
+        lexer::SourcePosition inferStart = lexer_->GetToken().Start();
+        lexer_->NextToken();
+
+        ir::TSTypeParameter *typeParam = ParseTsTypeParameter(true);
+
+        auto *inferType = AllocNode<ir::TSInferType>(typeParam);
+
+        inferType->SetRange({inferStart, lexer_->GetToken().End()});
+
+        return inferType;
+    }
+
+    return ParseTsIdentifierReference();
+}
+
+ir::Expression *ParserImpl::ParseTsTupleElement(ir::TSTupleKind *kind, bool *seenOptional)
+{
+    lexer::SourcePosition elementStart = lexer_->GetToken().Start();
+    ir::Expression *element = nullptr;
+    bool isOptional = false;
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT && !CurrentLiteralIsBasicType()) {
+        auto *elementIdent = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        elementIdent->SetRange(lexer_->GetToken().Loc());
+
+        if (lexer_->Lookahead() == LEX_CHAR_COLON || lexer_->Lookahead() == LEX_CHAR_QUESTION) {
+            if (*kind == ir::TSTupleKind::DEFAULT) {
+                ThrowSyntaxError("Tuple members must all have names or all not have names");
+            }
+
+            lexer_->NextToken();  // eat ident
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
+                lexer_->NextToken();  // eat '?'
+                isOptional = true;
+                *seenOptional = true;
+            } else if (*seenOptional) {
+                ThrowSyntaxError("A required element cannot follow an optional element");
+            }
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON) {
+                ThrowSyntaxError("':' expected");
+            }
+
+            lexer_->NextToken();  // eat ':'
+            auto *elementType = ParseTsTypeAnnotation(&options);
+            *kind = ir::TSTupleKind::NAMED;
+
+            element = AllocNode<ir::TSNamedTupleMember>(elementIdent, elementType, isOptional);
+        } else {
+            element = ParseTsTypeReferenceOrQuery();
+        }
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA &&
+            lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+            element = ParseTsTypeAnnotationElement(element, &options);
+        }
+    } else {
+        if (*kind == ir::TSTupleKind::NAMED) {
+            ThrowSyntaxError("Tuple members must all have names or all not have names");
+        }
+
+        *kind = ir::TSTupleKind::DEFAULT;
+        element = ParseTsTypeAnnotation(&options);
+    }
+
+    if (element) {
+        element->SetRange({elementStart, lexer_->GetToken().End()});
+    }
+    return element;
+}
+
+ir::TSTupleType *ParserImpl::ParseTsTupleType()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET);
+    lexer::SourcePosition tupleStart = lexer_->GetToken().Start();
+    ArenaVector<ir::Expression *> elements(Allocator()->Adapter());
+    ir::TSTupleKind kind = ir::TSTupleKind::NONE;
+    bool seenOptional = false;
+
+    lexer_->NextToken();  // eat '['
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+        ir::Expression *element = ParseTsTupleElement(&kind, &seenOptional);
+        elements.push_back(element);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+            break;
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA) {
+            ThrowSyntaxError("',' expected.");
+        }
+
+        lexer_->NextToken();  // eat ','
+    }
+
+    lexer::SourcePosition tupleEnd = lexer_->GetToken().End();
+    lexer_->NextToken();  // eat ']'
+
+    auto *tupleType = AllocNode<ir::TSTupleType>(std::move(elements));
+    tupleType->SetRange({tupleStart, tupleEnd});
+    return tupleType;
+}
+
+ir::Expression *ParserImpl::ParseTsQualifiedReference(ir::Expression *typeName)
+{
+    lexer::SourcePosition startLoc = typeName->Start();
+
+    do {
+        lexer_->NextToken();  // eat '.'
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+            ThrowSyntaxError("Identifier expected");
+        }
+
+        auto *propName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        propName->SetRange(lexer_->GetToken().Loc());
+
+        typeName = AllocNode<ir::TSQualifiedName>(typeName, propName);
+        typeName->SetRange({typeName->AsTSQualifiedName()->Left()->Start(), lexer_->GetToken().End()});
+
+        lexer_->NextToken();
+    } while (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD);
+
+    typeName->SetRange({startLoc, lexer_->GetToken().End()});
+
+    return typeName;
+}
+
+ir::Expression *ParserImpl::ParseTsIndexAccessType(ir::Expression *typeName)
+{
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+
+    do {
+        lexer_->NextToken();  // eat '['
+
+        ir::Expression *indexType = ParseTsTypeAnnotation(&options);
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+            ThrowSyntaxError("']' exprected");
+        }
+
+        lexer_->NextToken();  // eat ']'
+
+        typeName = AllocNode<ir::TSIndexedAccessType>(typeName, indexType);
+        typeName->SetRange({typeName->AsTSIndexedAccessType()->ObjectType()->Start(), lexer_->GetToken().End()});
+    } while (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET &&
+             lexer_->Lookahead() != LEX_CHAR_RIGHT_SQUARE);
+
+    return typeName;
+}
+
+ir::Expression *ParserImpl::ParseTsTypeReferenceOrQuery(bool parseQuery)
+{
+    lexer::SourcePosition referenceStartLoc = lexer_->GetToken().Start();
+
+    if (parseQuery) {
+        ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_TYPEOF);
+        lexer_->NextToken();  // eat 'typeof'
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_IMPORT) {
+            lexer::SourcePosition &startLoc = referenceStartLoc;
+            return ParseTsImportType(startLoc, true);
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+            ThrowSyntaxError("Identifier expected.");
+        }
+    }
+
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT ||
+           lexer_->GetToken().Type() == lexer::TokenType::KEYW_EXTENDS);
+
+    ir::Expression *typeName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    typeName->SetRange(lexer_->GetToken().Loc());
+
+    if (lexer_->Lookahead() == LEX_CHAR_LESS_THAN) {
+        lexer_->ForwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
+    } else {
+        lexer_->NextToken();
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+        typeName = ParseTsQualifiedReference(typeName);
+    }
+
+    ir::TSTypeParameterInstantiation *typeParamInst = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        if (parseQuery) {
+            ThrowSyntaxError("Unexpected token.");
+        }
+
+        typeParamInst = ParseTsTypeParameterInstantiation();
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET &&
+        lexer_->Lookahead() != LEX_CHAR_RIGHT_SQUARE) {
+        if (parseQuery) {
+            typeName = AllocNode<ir::TSTypeQuery>(typeName);
+        } else {
+            typeName = AllocNode<ir::TSTypeReference>(typeName, typeParamInst);
+        }
+
+        typeName->SetRange({referenceStartLoc, lexer_->GetToken().End()});
+
+        return ParseTsIndexAccessType(typeName);
+    }
+
+    ir::Expression *returnNode = nullptr;
+
+    lexer::SourcePosition referenceEndLoc = typeName->End();
+
+    if (parseQuery) {
+        returnNode = AllocNode<ir::TSTypeQuery>(typeName);
+    } else {
+        returnNode = AllocNode<ir::TSTypeReference>(typeName, typeParamInst);
+    }
+
+    returnNode->SetRange({referenceStartLoc, referenceEndLoc});
+
+    return returnNode;
+}
+
+ir::TSTypeParameter *ParserImpl::ParseTsMappedTypeParameter()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    auto *paramName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    paramName->SetRange({lexer_->GetToken().Start(), lexer_->GetToken().End()});
+
+    lexer_->NextToken();
+
+    lexer_->NextToken();  // eat 'in'
+
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+    ir::Expression *constraint = ParseTsTypeAnnotation(&options);
+
+    lexer::SourcePosition endLoc = constraint->End();
+
+    auto *typeParameter = AllocNode<ir::TSTypeParameter>(paramName, constraint, nullptr);
+
+    typeParameter->SetRange({startLoc, endLoc});
+
+    return typeParameter;
+}
+
+ir::MappedOption ParserImpl::ParseMappedOption(lexer::TokenType tokenType)
+{
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_MINUS &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_PLUS &&
+        lexer_->GetToken().KeywordType() != tokenType && lexer_->GetToken().Type() != tokenType) {
+        return ir::MappedOption::NO_OPTS;
+    }
+
+    auto result = lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MINUS ? ir::MappedOption::MINUS
+                                                                                  : ir::MappedOption::PLUS;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MINUS ||
+        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PLUS) {
+        lexer_->NextToken();
+    }
+
+    if (lexer_->GetToken().KeywordType() != tokenType && lexer_->GetToken().Type() != tokenType) {
+        ThrowSyntaxError({"'", TokenToString(tokenType), "' expected."});
+    }
+
+    lexer_->NextToken();
+
+    return result;
+}
+
+ir::TSMappedType *ParserImpl::ParseTsMappedType()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE);
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat '{'
+
+    ir::MappedOption readonly = ParseMappedOption(lexer::TokenType::KEYW_READONLY);
+
+    lexer_->NextToken();  // eat '['
+
+    ir::TSTypeParameter *typeParameter = ParseTsMappedTypeParameter();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+        ThrowSyntaxError("']' expected");
+    }
+
+    lexer_->NextToken();  // eat ']'
+
+    ir::MappedOption optional = ParseMappedOption(lexer::TokenType::PUNCTUATOR_QUESTION_MARK);
+
+    ir::Expression *typeAnnotation = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+        lexer_->NextToken();  // eat ':'
+        TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+        typeAnnotation = ParseTsTypeAnnotation(&options);
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ThrowSyntaxError("';' expected");
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        lexer_->NextToken();  // eat ';'
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ThrowSyntaxError("'}' expected");
+    }
+
+    auto *mappedType = AllocNode<ir::TSMappedType>(typeParameter, typeAnnotation, readonly, optional);
+
+    mappedType->SetRange({startLoc, lexer_->GetToken().End()});
+
+    lexer_->NextToken();  // eat '}'
+
+    return mappedType;
+}
+
+ir::TSTypePredicate *ParserImpl::ParseTsTypePredicate()
+{
+    auto pos = lexer_->Save();
+    lexer::SourcePosition startPos = lexer_->GetToken().Start();
+    bool isAsserts = lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ASSERTS;
+    if (isAsserts) {
+        lexer_->NextToken();  // eat 'asserts'
+        if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_IS) {
+            isAsserts = false;
+            lexer_->Rewind(pos);
+        }
+    }
+
+    ir::Expression *parameterName = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT) {
+        parameterName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    } else {
+        parameterName = AllocNode<ir::TSThisType>();
+    }
+
+    parameterName->SetRange({lexer_->GetToken().Start(), lexer_->GetToken().End()});
+
+    lexer_->NextToken();
+
+    ir::Expression *typeAnnotation = nullptr;
+    lexer::SourcePosition endPos;
+    ir::TSTypePredicate *result = nullptr;
+
+    if (isAsserts && lexer_->GetToken().KeywordType() != lexer::TokenType::KEYW_IS) {
+        endPos = parameterName->End();
+        result = AllocNode<ir::TSTypePredicate>(parameterName, typeAnnotation, isAsserts);
+        result->SetRange({startPos, endPos});
+        return result;
+    }
+
+    lexer_->NextToken();  // eat 'is'
+
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+    typeAnnotation = ParseTsTypeAnnotation(&options);
+    endPos = typeAnnotation->End();
+
+    result = AllocNode<ir::TSTypePredicate>(parameterName, typeAnnotation, isAsserts);
+
+    result->SetRange({startPos, endPos});
+
+    return result;
+}
+
+ir::Expression *ParserImpl::ParseTsTypeLiteralOrInterfaceKey(bool *computed, bool *signature, bool *isIndexSignature)
+{
+    ir::Expression *key = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
+        (lexer_->GetToken().KeywordType() != lexer::TokenType::KEYW_NEW ||
+         (lexer_->Lookahead() != LEX_CHAR_LEFT_PAREN && lexer_->Lookahead() != LEX_CHAR_LESS_THAN))) {
+        key = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        key->SetRange(lexer_->GetToken().Loc());
+        lexer_->NextToken();
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_NUMBER) {
+        if (lexer_->GetToken().Flags() & lexer::TokenFlags::NUMBER_BIGINT) {
+            key = AllocNode<ir::BigIntLiteral>(lexer_->GetToken().BigInt());
+        } else {
+            key = AllocNode<ir::NumberLiteral>(lexer_->GetToken().Number(), lexer_->GetToken().String());
+        }
+
+        key->SetRange(lexer_->GetToken().Loc());
+        lexer_->NextToken();
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING) {
+        key = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+        key->SetRange(lexer_->GetToken().Loc());
+        lexer_->NextToken();
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET) {
+        *computed = true;
+        lexer_->NextToken();  // eat '['
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT && lexer_->Lookahead() == LEX_CHAR_COLON) {
+            *isIndexSignature = true;
+            key = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+            key->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();  // eat param
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON) {
+                ThrowSyntaxError("':' expected");
+            }
+
+            lexer_->NextToken();  // eat ':'
+
+            TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+            ir::Expression *typeAnnotation = ParseTsTypeAnnotation(&options);
+
+            if (!typeAnnotation->IsTSNumberKeyword() && !typeAnnotation->IsTSStringKeyword()) {
+                ThrowSyntaxError(
+                    "An index signature parameter type must be either "
+                    "'string' or 'number'");
+            }
+
+            key->SetTsTypeAnnotation(typeAnnotation);
+        } else {
+            key = ParseExpression();
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+            ThrowSyntaxError("']' expected");
+        }
+
+        lexer_->NextToken();  // eat ']'
+    } else if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS &&
+               lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LESS_THAN &&
+               lexer_->GetToken().KeywordType() != lexer::TokenType::KEYW_NEW) {
+        ThrowSyntaxError("Unexpected token");
+    } else {
+        *signature = true;
+    }
+
+    return key;
+}
+
+ir::Expression *ParserImpl::ParseTsTypeLiteralOrInterfaceMember()
+{
+    bool computed = false;
+    bool optional = false;
+    bool signature = false;
+    bool readonly = false;
+    bool isConstructSignature = false;
+    bool isIndexSignature = false;
+    lexer::SourcePosition memberStartLoc = lexer_->GetToken().Start();
+    char32_t nextToken = lexer_->Lookahead();
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_READONLY && nextToken != LEX_CHAR_LEFT_PAREN &&
+        nextToken != LEX_CHAR_COLON && nextToken != LEX_CHAR_COMMA && nextToken != LEX_CHAR_LESS_THAN &&
+        nextToken != LEX_CHAR_SEMICOLON) {
+        readonly = true;
+        lexer_->NextToken();
+    }
+
+    ir::Expression *key = ParseTsTypeLiteralOrInterfaceKey(&computed, &signature, &isIndexSignature);
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
+        if (isIndexSignature) {
+            ThrowSyntaxError("';' expected");
+        }
+
+        optional = true;
+        lexer_->NextToken();  // eat '?'
+    }
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_NEW && signature) {
+        lexer_->NextToken();  // eat 'new'
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS &&
+            lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+            ThrowSyntaxError("'(' expected");
+        }
+
+        isConstructSignature = true;
+    }
+
+    ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        if (isIndexSignature) {
+            ThrowSyntaxError("';' expected");
+        }
+
+        typeParamDecl = ParseTsTypeParameterDeclaration();
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+            ThrowSyntaxError("'(' expected");
+        }
+    }
+
+    ir::Expression *member = nullptr;
+    ir::Expression *typeAnnotation = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS && !isIndexSignature) {
+        FunctionParameterContext funcParamContext(&context_, Binder());
+        auto *funcParamScope = funcParamContext.LexicalScope().GetScope();
+        ArenaVector<ir::Expression *> params = ParseFunctionParams(true);
+
+        ir::Expression *returnTypeAnnotation = nullptr;
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+            lexer_->NextToken();  // eat ':'
+            TypeAnnotationParsingOptions options =
+                TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::CAN_BE_TS_TYPE_PREDICATE;
+            returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+        }
+
+        if (signature) {
+            auto kind = isConstructSignature
+                            ? ir::TSSignatureDeclaration::TSSignatureDeclarationKind::CONSTRUCT_SIGNATURE
+                            : ir::TSSignatureDeclaration::TSSignatureDeclarationKind::CALL_SIGNATURE;
+            member = AllocNode<ir::TSSignatureDeclaration>(funcParamScope, kind, typeParamDecl, std::move(params),
+                                                           returnTypeAnnotation);
+            funcParamScope->BindNode(member);
+        } else {
+            member = AllocNode<ir::TSMethodSignature>(funcParamScope, key, typeParamDecl, std::move(params),
+                                                      returnTypeAnnotation, computed, optional);
+            funcParamScope->BindNode(member);
+        }
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+        lexer_->NextToken();  // eat ':'
+        TypeAnnotationParsingOptions options =
+            TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::BREAK_AT_NEW_LINE;
+        typeAnnotation = ParseTsTypeAnnotation(&options);
+    } else if (isIndexSignature) {
+        ThrowSyntaxError("An index signature must have a type annotation.", memberStartLoc);
+    }
+
+    if (!member && isIndexSignature) {
+        member = AllocNode<ir::TSIndexSignature>(key, typeAnnotation, readonly);
+    } else if (!member) {
+        member = AllocNode<ir::TSPropertySignature>(key, typeAnnotation, computed, optional, readonly);
+    } else if (readonly) {
+        ThrowSyntaxError(
+            "'readonly' modifier can only appear on a property "
+            "declaration or index signature.",
+            memberStartLoc);
+    }
+
+    member->SetRange({memberStartLoc, lexer_->GetToken().End()});
+
+    return member;
+}
+
+ArenaVector<ir::Expression *> ParserImpl::ParseTsTypeLiteralOrInterface()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE);
+
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat '{'
+
+    ArenaVector<ir::Expression *> members(Allocator()->Adapter());
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ir::Expression *member = ParseTsTypeLiteralOrInterfaceMember();
+        members.push_back(member);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+            break;
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA &&
+            lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+            if (!lexer_->GetToken().NewLine()) {
+                ThrowSyntaxError("',' expected");
+            }
+
+            if (lexer_->GetToken().IsKeyword()) {
+                lexer_->GetToken().SetTokenType(lexer::TokenType::LITERAL_IDENT);
+            }
+
+            continue;
+        }
+
+        lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+    }
+
+    return members;
+}
+
+ir::TSArrayType *ParserImpl::ParseTsArrayType(ir::Expression *elementType)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET);
+    lexer_->NextToken();  // eat '['
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+        ThrowSyntaxError("']' expected");
+    }
+
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();  // eat ']'
+
+    lexer::SourcePosition startLoc = elementType->Start();
+    auto *arrayType = AllocNode<ir::TSArrayType>(elementType);
+    arrayType->SetRange({startLoc, endLoc});
+
+    return arrayType;
+}
+
+ir::TSUnionType *ParserImpl::ParseTsUnionType(ir::Expression *type, bool restrictExtends)
+{
+    ArenaVector<ir::Expression *> types(Allocator()->Adapter());
+    lexer::SourcePosition startLoc;
+
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::IN_UNION;
+
+    if (restrictExtends) {
+        options |= TypeAnnotationParsingOptions::RESTRICT_EXTENDS;
+    }
+
+    if (type) {
+        startLoc = type->Start();
+        types.push_back(type);
+    } else {
+        startLoc = lexer_->GetToken().Start();
+    }
+
+    while (true) {
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_BITWISE_OR) {
+            break;
+        }
+
+        lexer_->NextToken();  // eat '|'
+
+        types.push_back(ParseTsTypeAnnotation(&options));
+    }
+
+    lexer::SourcePosition endLoc = types.back()->End();
+
+    auto *unionType = AllocNode<ir::TSUnionType>(std::move(types));
+    unionType->SetRange({startLoc, endLoc});
+
+    return unionType;
+}
+
+ir::TSIntersectionType *ParserImpl::ParseTsIntersectionType(ir::Expression *type, bool inUnion, bool restrictExtends)
+{
+    ArenaVector<ir::Expression *> types(Allocator()->Adapter());
+    lexer::SourcePosition startLoc;
+
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::IN_INTERSECTION;
+
+    if (restrictExtends) {
+        options |= TypeAnnotationParsingOptions::RESTRICT_EXTENDS;
+    }
+
+    if (inUnion) {
+        options |= TypeAnnotationParsingOptions::IN_UNION;
+    }
+
+    if (type) {
+        startLoc = type->Start();
+        types.push_back(type);
+    } else {
+        startLoc = lexer_->GetToken().Start();
+    }
+
+    while (true) {
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_BITWISE_AND) {
+            break;
+        }
+
+        lexer_->NextToken();  // eat '&'
+
+        types.push_back(ParseTsTypeAnnotation(&options));
+    }
+
+    lexer::SourcePosition endLoc = types.back()->End();
+
+    auto *intersectionType = AllocNode<ir::TSIntersectionType>(std::move(types));
+
+    intersectionType->SetRange({startLoc, endLoc});
+    return intersectionType;
+}
+
+ir::Expression *ParserImpl::ParseTsParenthesizedOrFunctionType(ir::Expression *typeAnnotation, bool throwError)
+{
+    if (typeAnnotation) {
+        return nullptr;
+    }
+
+    lexer::SourcePosition typeStart = lexer_->GetToken().Start();
+
+    bool abstractConstructor = lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ABSTRACT;
+    if (abstractConstructor) {
+        lexer_->NextToken();  // eat 'abstract'
+    }
+
+    bool isConstructionType = false;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_NEW) {
+        lexer_->NextToken();  // eat 'new'
+        isConstructionType = true;
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS &&
+            lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+            ThrowSyntaxError("'(' expected");
+        }
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN || isConstructionType) {
+        return ParseTsFunctionType(typeStart, isConstructionType, throwError, abstractConstructor);
+    }
+
+    const auto startPos = lexer_->Save();
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS);
+    lexer_->NextToken();  // eat '('
+
+    char32_t nextCp = lexer_->Lookahead();
+    if (nextCp == LEX_CHAR_COMMA || nextCp == LEX_CHAR_QUESTION || nextCp == LEX_CHAR_COLON ||
+        (!CurrentIsBasicType() && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS)) {
+        lexer_->Rewind(startPos);
+        return ParseTsFunctionType(typeStart, false, throwError);
+    }
+
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::NO_OPTS;
+    ir::Expression *type = ParseTsTypeAnnotation(&options);
+
+    if (!type) {
+        lexer_->Rewind(startPos);
+        return ParseTsFunctionType(typeStart, false, throwError);
+    }
+
+    if (throwError && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("')' expected");
+    }
+
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();  // eat ')'
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_ARROW) {
+        lexer_->Rewind(startPos);
+
+        return ParseTsFunctionType(typeStart, false, throwError);
+    }
+
+    auto *result = AllocNode<ir::TSParenthesizedType>(type);
+    result->SetRange({typeStart, endLoc});
+
+    return result;
+}
+
+ir::Expression *ParserImpl::ParseTsFunctionType(lexer::SourcePosition startLoc, bool isConstructionType,
+                                                bool throwError, bool abstractConstructor)
+{
+    ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        typeParamDecl = ParseTsTypeParameterDeclaration(throwError);
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+            if (!throwError) {
+                return nullptr;
+            }
+
+            ThrowSyntaxError("'(' expected");
+        }
+    }
+
+    FunctionParameterContext funcParamContext(&context_, Binder());
+    auto *funcParamScope = funcParamContext.LexicalScope().GetScope();
+    ArenaVector<ir::Expression *> params = ParseFunctionParams(true);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_ARROW) {
+        ThrowSyntaxError("'=>' expected");
+    }
+
+    lexer_->NextToken();  // eat '=>'
+
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::CAN_BE_TS_TYPE_PREDICATE;
+    ir::Expression *returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+
+    ir::Expression *funcType = nullptr;
+
+    if (isConstructionType) {
+        funcType = AllocNode<ir::TSConstructorType>(funcParamScope, std::move(params), typeParamDecl,
+                                                    returnTypeAnnotation, abstractConstructor);
+    } else {
+        funcType =
+            AllocNode<ir::TSFunctionType>(funcParamScope, std::move(params), typeParamDecl, returnTypeAnnotation);
+    }
+
+    funcType->SetRange({startLoc, returnTypeAnnotation->End()});
+    funcParamScope->BindNode(funcType);
+
+    return funcType;
+}
+
+ir::Expression *ParserImpl::ParseTsBasicType()
+{
+    ir::Expression *typeAnnotation = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MINUS) {
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_NUMBER) {
+            ThrowSyntaxError("Type expected");
+        }
+    }
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_NUMBER) {
+        if (lexer_->GetToken().Flags() & lexer::TokenFlags::NUMBER_BIGINT) {
+            auto *bigintNode = AllocNode<ir::BigIntLiteral>(lexer_->GetToken().BigInt());
+            bigintNode->SetRange(lexer_->GetToken().Loc());
+
+            typeAnnotation = AllocNode<ir::TSLiteralType>(bigintNode);
+        } else {
+            auto *numberNode = AllocNode<ir::NumberLiteral>(lexer_->GetToken().Number(), lexer_->GetToken().String());
+            numberNode->SetRange(lexer_->GetToken().Loc());
+
+            typeAnnotation = AllocNode<ir::TSLiteralType>(numberNode);
+        }
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING) {
+        auto *stringNode = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+        stringNode->SetRange(lexer_->GetToken().Loc());
+
+        typeAnnotation = AllocNode<ir::TSLiteralType>(stringNode);
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_TRUE) {
+        auto *booleanLiteral = AllocNode<ir::BooleanLiteral>(true);
+        booleanLiteral->SetRange(lexer_->GetToken().Loc());
+
+        typeAnnotation = AllocNode<ir::TSLiteralType>(booleanLiteral);
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_FALSE) {
+        auto *booleanLiteral = AllocNode<ir::BooleanLiteral>(false);
+        booleanLiteral->SetRange(lexer_->GetToken().Loc());
+
+        typeAnnotation = AllocNode<ir::TSLiteralType>(booleanLiteral);
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ANY) {
+        typeAnnotation = AllocNode<ir::TSAnyKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_BOOLEAN) {
+        typeAnnotation = AllocNode<ir::TSBooleanKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_NUMBER) {
+        typeAnnotation = AllocNode<ir::TSNumberKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_STRING) {
+        typeAnnotation = AllocNode<ir::TSStringKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_UNKNOWN) {
+        typeAnnotation = AllocNode<ir::TSUnknownKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_VOID) {
+        typeAnnotation = AllocNode<ir::TSVoidKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::LITERAL_NULL) {
+        typeAnnotation = AllocNode<ir::TSNullKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_UNDEFINED) {
+        typeAnnotation = AllocNode<ir::TSUndefinedKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_NEVER) {
+        typeAnnotation = AllocNode<ir::TSNeverKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_OBJECT) {
+        typeAnnotation = AllocNode<ir::TSObjectKeyword>();
+    } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_BIGINT) {
+        typeAnnotation = AllocNode<ir::TSBigintKeyword>();
+    } else {
+        ThrowSyntaxError("Unexpected type");
+    }
+
+    typeAnnotation->SetRange(lexer_->GetToken().Loc());
+
+    lexer_->NextToken();
+    return typeAnnotation;
+}
+
+static ir::ModifierFlags GetAccessability(ir::ModifierFlags modifiers)
+{
+    if (modifiers & ir::ModifierFlags::PUBLIC) {
+        return ir::ModifierFlags::PUBLIC;
+    }
+
+    if (modifiers & ir::ModifierFlags::PRIVATE) {
+        return ir::ModifierFlags::PRIVATE;
+    }
+
+    if (modifiers & ir::ModifierFlags::PROTECTED) {
+        return ir::ModifierFlags::PROTECTED;
+    }
+
+    return ir::ModifierFlags::NONE;
+}
+
+static bool IsModifierKind(const lexer::Token &token)
+{
+    if (token.Type() == lexer::TokenType::LITERAL_IDENT) {
+        switch (token.KeywordType()) {
+            case lexer::TokenType::KEYW_PUBLIC:
+            case lexer::TokenType::KEYW_PRIVATE:
+            case lexer::TokenType::KEYW_PROTECTED:
+            case lexer::TokenType::KEYW_STATIC:
+            case lexer::TokenType::KEYW_ASYNC:
+            case lexer::TokenType::KEYW_ABSTRACT:
+            case lexer::TokenType::KEYW_DECLARE:
+            case lexer::TokenType::KEYW_READONLY:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    return false;
+}
+
+ir::ModifierFlags ParserImpl::ParseModifiers()
+{
+    ir::ModifierFlags resultStatus = ir::ModifierFlags::NONE;
+    ir::ModifierFlags prevStatus = ir::ModifierFlags::ALL;
+
+    while (IsModifierKind(lexer_->GetToken())) {
+        char32_t nextCp = lexer_->Lookahead();
+        if (!((Extension() == ScriptExtension::JS && nextCp != LEX_CHAR_LEFT_PAREN) ||
+              (Extension() == ScriptExtension::TS && nextCp != LEX_CHAR_EQUALS && nextCp != LEX_CHAR_SEMICOLON &&
+               nextCp != LEX_CHAR_LEFT_PAREN))) {
+            break;
+        }
+
+        lexer::TokenFlags tokenFlags = lexer_->GetToken().Flags();
+        if (tokenFlags & lexer::TokenFlags::HAS_ESCAPE) {
+            ThrowSyntaxError("Keyword must not contain escaped characters");
+        }
+
+        ir::ModifierFlags actualStatus = ir::ModifierFlags::NONE;
+        ir::ModifierFlags nextStatus = ir::ModifierFlags::NONE;
+
+        switch (lexer_->GetToken().KeywordType()) {
+            case lexer::TokenType::KEYW_PUBLIC: {
+                actualStatus = ir::ModifierFlags::PUBLIC;
+                nextStatus = ir::ModifierFlags::ASYNC | ir::ModifierFlags::STATIC | ir::ModifierFlags::READONLY |
+                             ir::ModifierFlags::DECLARE | ir::ModifierFlags::ABSTRACT;
+                break;
+            }
+            case lexer::TokenType::KEYW_PRIVATE: {
+                actualStatus = ir::ModifierFlags::PRIVATE;
+                nextStatus = ir::ModifierFlags::ASYNC | ir::ModifierFlags::STATIC | ir::ModifierFlags::READONLY |
+                             ir::ModifierFlags::DECLARE | ir::ModifierFlags::ABSTRACT;
+                break;
+            }
+            case lexer::TokenType::KEYW_PROTECTED: {
+                actualStatus = ir::ModifierFlags::PROTECTED;
+                nextStatus = ir::ModifierFlags::ASYNC | ir::ModifierFlags::STATIC | ir::ModifierFlags::READONLY |
+                             ir::ModifierFlags::DECLARE | ir::ModifierFlags::ABSTRACT;
+                break;
+            }
+            case lexer::TokenType::KEYW_STATIC: {
+                actualStatus = ir::ModifierFlags::STATIC;
+                nextStatus = ir::ModifierFlags::ASYNC | ir::ModifierFlags::READONLY | ir::ModifierFlags::DECLARE |
+                             ir::ModifierFlags::ABSTRACT;
+                break;
+            }
+            case lexer::TokenType::KEYW_ASYNC: {
+                actualStatus = ir::ModifierFlags::ASYNC;
+                nextStatus = ir::ModifierFlags::READONLY | ir::ModifierFlags::DECLARE | ir::ModifierFlags::ABSTRACT;
+                break;
+            }
+            case lexer::TokenType::KEYW_ABSTRACT: {
+                actualStatus = ir::ModifierFlags::ABSTRACT;
+                nextStatus = ir::ModifierFlags::ACCESS | ir::ModifierFlags::ASYNC | ir::ModifierFlags::STATIC |
+                             ir::ModifierFlags::READONLY | ir::ModifierFlags::DECLARE;
+                break;
+            }
+            case lexer::TokenType::KEYW_DECLARE: {
+                actualStatus = ir::ModifierFlags::DECLARE;
+                nextStatus = ir::ModifierFlags::ACCESS | ir::ModifierFlags::ASYNC | ir::ModifierFlags::STATIC |
+                             ir::ModifierFlags::READONLY;
+                break;
+            }
+            case lexer::TokenType::KEYW_READONLY: {
+                actualStatus = ir::ModifierFlags::READONLY;
+                nextStatus = ir::ModifierFlags::ASYNC | ir::ModifierFlags::DECLARE | ir::ModifierFlags::ABSTRACT;
+                break;
+            }
+            default: {
+                UNREACHABLE();
+            }
+        }
+
+        if (lexer_->Lookahead() == LEX_CHAR_COLON || lexer_->Lookahead() == LEX_CHAR_COMMA ||
+            lexer_->Lookahead() == LEX_CHAR_RIGHT_PAREN || lexer_->Lookahead() == LEX_CHAR_QUESTION ||
+            lexer_->Lookahead() == LEX_CHAR_RIGHT_BRACE || lexer_->Lookahead() == LEX_CHAR_LESS_THAN) {
+            break;
+        }
+
+        auto pos = lexer_->Save();
+        lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+
+        if ((prevStatus & actualStatus) == 0) {
+            lexer_->Rewind(pos);
+            ThrowSyntaxError("Unexpected modifier");
+        }
+
+        if ((resultStatus & actualStatus) != 0) {
+            lexer_->Rewind(pos);
+            ThrowSyntaxError("Duplicated modifier is not allowed");
+        }
+
+        if ((context_.Status() & ParserStatus::CONSTRUCTOR_FUNCTION) &&
+            (actualStatus & ~ir::ModifierFlags::ALLOWED_IN_CTOR_PARAMETER)) {
+            lexer_->Rewind(pos);
+            ThrowParameterModifierError(actualStatus);
+        }
+
+        resultStatus |= actualStatus;
+        prevStatus = nextStatus;
+    }
+
+    return resultStatus;
+}
+
+void ParserImpl::CheckAccessorPair(const ArenaVector<ir::Statement *> &properties, const ir::Expression *propName,
+                                   ir::MethodDefinitionKind methodKind, ir::ModifierFlags access, bool hasDecorator,
+                                   lexer::SourcePosition errorInfo)
+{
+    for (const auto &it : properties) {
+        if (!it->IsMethodDefinition() || (!hasDecorator && it->AsMethodDefinition()->Kind() != methodKind)) {
+            continue;
+        }
+
+        const ir::Expression *key = it->AsMethodDefinition()->Key();
+
+        if (key->Type() != propName->Type()) {
+            continue;
+        }
+
+        bool keyIsSame = false;
+
+        if (key->IsIdentifier()) {
+            const util::StringView &strName = propName->AsIdentifier()->Name();
+            const util::StringView &compareName = (key->AsIdentifier()->Name());
+
+            keyIsSame = strName == compareName;
+        } else if (key->IsNumberLiteral()) {
+            keyIsSame = *key->AsNumberLiteral() == *propName->AsNumberLiteral();
+        } else if (key->IsStringLiteral()) {
+            keyIsSame = *key->AsStringLiteral() == *propName->AsStringLiteral();
+        }
+
+        if (!keyIsSame) {
+            continue;
+        }
+
+        if (hasDecorator &&
+            (it->AsMethodDefinition()->Kind() == ir::MethodDefinitionKind::GET ||
+             it->AsMethodDefinition()->Kind() == ir::MethodDefinitionKind::SET) &&
+            !it->AsMethodDefinition()->Decorators().empty()) {
+            ThrowSyntaxError("Decorators cannot be applied to multiple get/set accessors of the same name.", errorInfo);
+        }
+
+        if (it->AsMethodDefinition()->Kind() != methodKind) {
+            continue;
+        }
+
+        ir::ModifierFlags getAccess = ir::ModifierFlags::NONE;
+        ir::ModifierFlags setAccess = ir::ModifierFlags::NONE;
+
+        if (methodKind == ir::MethodDefinitionKind::GET) {
+            setAccess = access;
+            getAccess = GetAccessability(it->AsMethodDefinition()->Modifiers());
+        } else {
+            getAccess = access;
+            setAccess = GetAccessability(it->AsMethodDefinition()->Modifiers());
+        }
+
+        if ((setAccess == ir::ModifierFlags::NONE && getAccess > ir::ModifierFlags::PUBLIC) ||
+            (setAccess != ir::ModifierFlags::NONE && getAccess > setAccess)) {
+            ThrowSyntaxError("A get accessor must be at least as accessible as the setter", key->Start());
+        }
+    }
+}
+
+void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
+{
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        return;
+    }
+
+    char32_t nextCp = lexer_->Lookahead();
+
+    if ((Extension() == ScriptExtension::JS && nextCp != LEX_CHAR_LEFT_PAREN) ||
+        (Extension() == ScriptExtension::TS && nextCp != LEX_CHAR_EQUALS && nextCp != LEX_CHAR_SEMICOLON &&
+         nextCp != LEX_CHAR_LEFT_PAREN)) {
+        if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_GET) {
+            if (desc->isPrivateIdent) {
+                ThrowSyntaxError("Private identifier can not be getter");
+            }
+
+            if (lexer_->GetToken().Flags() & lexer::TokenFlags::HAS_ESCAPE) {
+                ThrowSyntaxError("Keyword must not contain escaped characters");
+            }
+
+            desc->methodKind = ir::MethodDefinitionKind::GET;
+            desc->methodStart = lexer_->GetToken().Start();
+
+            lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+        } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_SET) {
+            if (desc->isPrivateIdent) {
+                ThrowSyntaxError("Private identifier can not be setter");
+            }
+
+            if (lexer_->GetToken().Flags() & lexer::TokenFlags::HAS_ESCAPE) {
+                ThrowSyntaxError("Keyword must not contain escaped characters");
+            }
+
+            desc->methodKind = ir::MethodDefinitionKind::SET;
+            desc->methodStart = lexer_->GetToken().Start();
+
+            lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+        }
+    }
+}
+
+void ParserImpl::ThrowIfPrivateIdent(ClassElmentDescriptor *desc, const char *msg)
+{
+    if (desc->isPrivateIdent) {
+        ThrowSyntaxError(msg);
+    }
+}
+
+void ParserImpl::ValidateClassKey(ClassElmentDescriptor *desc)
+{
+    if ((desc->modifiers & ir::ModifierFlags::ASYNC) &&
+        (desc->methodKind == ir::MethodDefinitionKind::GET || desc->methodKind == ir::MethodDefinitionKind::SET)) {
+        ThrowSyntaxError("Async method can not be getter nor setter");
+    }
+
+    const util::StringView &propNameStr = lexer_->GetToken().Ident();
+
+    if (propNameStr.Is("constructor")) {
+        ThrowIfPrivateIdent(desc, "Private identifier can not be constructor");
+
+        if (!(desc->modifiers & ir::ModifierFlags::STATIC)) {
+            if ((desc->modifiers & ir::ModifierFlags::ASYNC) || desc->methodKind == ir::MethodDefinitionKind::GET ||
+                desc->methodKind == ir::MethodDefinitionKind::SET || desc->isGenerator) {
+                ThrowSyntaxError("Constructor can not be special method");
+            }
+
+            desc->methodKind = ir::MethodDefinitionKind::CONSTRUCTOR;
+            desc->methodStart = lexer_->GetToken().Start();
+            desc->newStatus |= ParserStatus::CONSTRUCTOR_FUNCTION;
+
+            if (desc->hasSuperClass) {
+                desc->newStatus |= ParserStatus::ALLOW_SUPER_CALL;
+            }
+        } else if (Extension() == ScriptExtension::TS) {
+            ThrowSyntaxError("Static modifier can not appear on a constructor");
+        }
+    } else if (propNameStr.Is("prototype") && (desc->modifiers & ir::ModifierFlags::STATIC)) {
+        ThrowSyntaxError("Classes may not have static property named prototype");
+    }
+}
+
+ir::Expression *ParserImpl::ParseClassKey(ClassElmentDescriptor *desc)
+{
+    ir::Expression *propName = nullptr;
+    if (lexer_->GetToken().IsKeyword()) {
+        lexer_->GetToken().SetTokenType(lexer::TokenType::LITERAL_IDENT);
+    }
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::LITERAL_IDENT: {
+            ValidateClassKey(desc);
+
+            propName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+            propName->SetRange(lexer_->GetToken().Loc());
+            break;
+        }
+        case lexer::TokenType::LITERAL_STRING: {
+            ThrowIfPrivateIdent(desc, "Private identifier name can not be string");
+
+            propName = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+            propName->SetRange(lexer_->GetToken().Loc());
+            break;
+        }
+        case lexer::TokenType::LITERAL_NUMBER: {
+            ThrowIfPrivateIdent(desc, "Private identifier name can not be number");
+
+            if (lexer_->GetToken().Flags() & lexer::TokenFlags::NUMBER_BIGINT) {
+                propName = AllocNode<ir::BigIntLiteral>(lexer_->GetToken().BigInt());
+            } else {
+                propName = AllocNode<ir::NumberLiteral>(lexer_->GetToken().Number(), lexer_->GetToken().String());
+            }
+
+            propName->SetRange(lexer_->GetToken().Loc());
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET: {
+            ThrowIfPrivateIdent(desc, "Unexpected character in private identifier");
+
+            lexer_->NextToken();  // eat left square bracket
+
+            if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
+                lexer_->Lookahead() == LEX_CHAR_COLON) {
+                desc->isIndexSignature = true;
+
+                propName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+                propName->SetRange(lexer_->GetToken().Loc());
+
+                lexer_->NextToken();  // eat param
+
+                if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON) {
+                    ThrowSyntaxError("':' expected");
+                }
+
+                lexer_->NextToken();  // eat ':'
+                TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+                ir::Expression *typeAnnotation = ParseTsTypeAnnotation(&options);
+
+                if (!typeAnnotation->IsTSNumberKeyword() && !typeAnnotation->IsTSStringKeyword()) {
+                    ThrowSyntaxError(
+                        "An index signature parameter type must be either "
+                        "'string' or 'number'");
+                }
+
+                propName->SetTsTypeAnnotation(typeAnnotation);
+
+                if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+                    ThrowSyntaxError("']' expected");
+                }
+
+                lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+
+                return propName;
+            }
+
+            desc->isComputed = true;
+
+            propName = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+            if (Extension() == ScriptExtension::TS) {
+                desc->invalidComputedProperty =
+                    !propName->IsNumberLiteral() && !propName->IsStringLiteral() &&
+                    !(propName->IsMemberExpression() && propName->AsMemberExpression()->Object()->IsIdentifier() &&
+                      propName->AsMemberExpression()->Object()->AsIdentifier()->Name().Is("Symbol"));
+            }
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_SQUARE_BRACKET) {
+                ThrowSyntaxError("Unexpected token, expected ']'");
+            }
+            break;
+        }
+        default: {
+            ThrowSyntaxError("Unexpected token in class property");
+        }
+    }
+
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+
+    return propName;
+}
+
+void ParserImpl::ValidateClassMethodStart(ClassElmentDescriptor *desc, ir::Expression *typeAnnotation)
+{
+    if (Extension() == ScriptExtension::JS) {
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+            return;
+        }
+        desc->classMethod = true;
+    }
+
+    if (Extension() == ScriptExtension::TS &&
+        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS && desc->isPrivateIdent) {
+        ThrowSyntaxError("A method cannot be named with a private identifier");
+    }
+
+    if (Extension() == ScriptExtension::TS) {
+        if (!typeAnnotation && (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS ||
+                                lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN)) {
+            if ((desc->modifiers & (ir::ModifierFlags::DECLARE | ir::ModifierFlags::READONLY))) {
+                ThrowSyntaxError("Class method can not be declare nor readonly");
+            }
+            desc->classMethod = true;
+        } else {
+            if ((desc->modifiers & ir::ModifierFlags::ASYNC) || desc->isGenerator) {
+                ThrowSyntaxError("Expected '('");
+            }
+            desc->classField = true;
+
+            if (desc->invalidComputedProperty) {
+                ThrowSyntaxError(
+                    "Computed property name must refer to a symbol or "
+                    "literal expression whos value is "
+                    "number or string");
+            }
+        }
+    }
+
+    if (desc->modifiers & ir::ModifierFlags::ASYNC) {
+        desc->newStatus |= ParserStatus::ASYNC_FUNCTION;
+    }
+
+    if (desc->isGenerator) {
+        desc->newStatus |= ParserStatus::GENERATOR_FUNCTION;
+    }
+}
+
+void ParserImpl::ValidateClassSetter(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
+                                     ir::Expression *propName, ir::ScriptFunction *func, bool hasDecorator,
+                                     lexer::SourcePosition errorInfo)
+{
+    if (func->Params().size() != 1) {
+        ThrowSyntaxError("Setter must have exactly one formal parameter");
+    }
+
+    if (Extension() == ScriptExtension::TS && !(desc->modifiers & ir::ModifierFlags::STATIC)) {
+        ir::ModifierFlags access = GetAccessability(desc->modifiers);
+        CheckAccessorPair(properties, propName, ir::MethodDefinitionKind::GET, access, hasDecorator, errorInfo);
+    }
+}
+
+void ParserImpl::ValidateClassGetter(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
+                                     ir::Expression *propName, ir::ScriptFunction *func, bool hasDecorator,
+                                     lexer::SourcePosition errorInfo)
+{
+    if (!func->Params().empty()) {
+        ThrowSyntaxError("Getter must not have formal parameters");
+    }
+
+    if (Extension() == ScriptExtension::TS && !(desc->modifiers & ir::ModifierFlags::STATIC)) {
+        ir::ModifierFlags access = GetAccessability(desc->modifiers);
+
+        CheckAccessorPair(properties, propName, ir::MethodDefinitionKind::SET, access, hasDecorator, errorInfo);
+    }
+}
+
+ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElmentDescriptor *desc,
+                                                   const ArenaVector<ir::Statement *> &properties,
+                                                   ir::Expression *propName, lexer::SourcePosition *propEnd,
+                                                   ArenaVector<ir::Decorator *> &&decorators, bool isDeclare)
+{
+    if (Extension() == ScriptExtension::TS) {
+        if (desc->methodKind == ir::MethodDefinitionKind::SET || desc->methodKind == ir::MethodDefinitionKind::GET) {
+            desc->newStatus |= ParserStatus::ACCESSOR_FUNCTION;
+        }
+
+        desc->newStatus |= ParserStatus::IN_METHOD_DEFINITION;
+    }
+
+    if (isDeclare && (desc->newStatus & ParserStatus::ASYNC_FUNCTION)) {
+        ThrowSyntaxError("'async' modifier cannot be used in an ambient context.");
+    }
+
+    if (isDeclare && desc->isGenerator) {
+        ThrowSyntaxError("Generators are not allowed in an ambient context.");
+    }
+
+    ir::ScriptFunction *func = ParseFunction(desc->newStatus, isDeclare);
+
+    if (func->IsOverload() && !decorators.empty()) {
+        ThrowSyntaxError("A decorator can only decorate a method implementation, not an overload.",
+                         decorators.front()->Start());
+    }
+
+    auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    funcExpr->SetRange(func->Range());
+
+    lexer::SourcePosition errorInfo = decorators.empty() ? func->Start() : decorators[0]->Start();
+
+    if (desc->methodKind == ir::MethodDefinitionKind::SET) {
+        ValidateClassSetter(desc, properties, propName, func, !decorators.empty(), errorInfo);
+    } else if (desc->methodKind == ir::MethodDefinitionKind::GET) {
+        ValidateClassGetter(desc, properties, propName, func, !decorators.empty(), errorInfo);
+    }
+
+    *propEnd = func->End();
+    func->AddFlag(ir::ScriptFunctionFlags::METHOD);
+    auto *method = AllocNode<ir::MethodDefinition>(desc->methodKind, propName, funcExpr, desc->modifiers, Allocator(),
+                                                   std::move(decorators), desc->isComputed);
+    method->SetRange(funcExpr->Range());
+    return method;
+}
+
+ir::Statement *ParserImpl::ParseClassProperty(ClassElmentDescriptor *desc,
+                                              const ArenaVector<ir::Statement *> &properties, ir::Expression *propName,
+                                              ir::Expression *typeAnnotation, ArenaVector<ir::Decorator *> &&decorators,
+                                              bool isDeclare)
+{
+    lexer::SourcePosition propEnd = propName->End();
+    ir::Statement *property = nullptr;
+
+    if (desc->classMethod) {
+        property = ParseClassMethod(desc, properties, propName, &propEnd, std::move(decorators), isDeclare);
+        property->SetRange({desc->propStart, propEnd});
+        return property;
+    }
+
+    ir::Expression *value = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        lexer_->NextToken();  // eat equals
+
+        if (isDeclare) {
+            ThrowSyntaxError("Initializers are not allowed in ambient contexts.");
+        }
+        value = ParseExpression();
+        propEnd = value->End();
+    }
+
+    ir::Expression *privateId = nullptr;
+
+    if (Extension() == ScriptExtension::JS) {
+        if (desc->isPrivateIdent) {
+            ThrowSyntaxError("Private js fields are not supported");
+        }
+    } else {
+        if (desc->isPrivateIdent) {
+            privateId = AllocNode<ir::TSPrivateIdentifier>(propName, value, typeAnnotation);
+            privateId->SetRange({desc->propStart, propName->End()});
+        }
+    }
+
+    property = AllocNode<ir::ClassProperty>(desc->isPrivateIdent ? privateId : propName, value, typeAnnotation,
+                                            desc->modifiers, std::move(decorators), desc->isComputed,
+                                            desc->modifiers & ir::ModifierFlags::DEFINITE);
+
+    property->SetRange({desc->propStart, propEnd});
+    return property;
+}
+
+void ParserImpl::CheckClassGeneratorMethod(ClassElmentDescriptor *desc)
+{
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_MULTIPLY) {
+        return;
+    }
+
+    ThrowIfPrivateIdent(desc, "Unexpected character in private identifier");
+
+    desc->isGenerator = true;
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+}
+
+void ParserImpl::CheckClassPrivateIdentifier(ClassElmentDescriptor *desc)
+{
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_HASH_MARK) {
+        return;
+    }
+
+    if (Extension() == ScriptExtension::JS) {
+        ThrowSyntaxError("JS private class fields are not supported.");
+    }
+
+    if (Extension() == ScriptExtension::AS) {
+        return;
+    }
+
+    if (desc->modifiers != ir::ModifierFlags::NONE) {
+        ThrowSyntaxError("Unexpected modifier on private identifier");
+    }
+
+    desc->isPrivateIdent = true;
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+}
+
+ir::Expression *ParserImpl::ParseClassKeyAnnotation()
+{
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+        lexer_->NextToken();  // eat ':'
+        TypeAnnotationParsingOptions options =
+            TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::BREAK_AT_NEW_LINE;
+        return ParseTsTypeAnnotation(&options);
+    }
+
+    return nullptr;
+}
+
+ir::Decorator *ParserImpl::ParseDecorator()
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_AT);
+
+    lexer::SourcePosition start = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat '@'
+
+    ir::Expression *expr = ParseLeftHandSideExpression();
+    auto *result = AllocNode<ir::Decorator>(expr);
+    result->SetRange({start, expr->End()});
+
+    return result;
+}
+
+ArenaVector<ir::Decorator *> ParserImpl::ParseDecorators()
+{
+    ArenaVector<ir::Decorator *> decorators(Allocator()->Adapter());
+    auto savedStatus = context_.Status();
+    context_.Status() |= ParserStatus::IN_DECORATOR;
+
+    while (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_AT) {
+        decorators.push_back(ParseDecorator());
+    }
+
+    if (!decorators.empty() && lexer_->GetToken().Type() != lexer::TokenType::KEYW_CLASS &&
+        (context_.Status() & ParserStatus::IN_CLASS_BODY) == 0 &&
+        lexer_->GetToken().Type() != lexer::TokenType::KEYW_EXPORT &&
+        !(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
+          lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_DECLARE)) {
+        ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
+    }
+
+    context_.Status() = savedStatus;
+    return decorators;
+}
+
+ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *> &properties,
+                                             ArenaVector<ir::TSIndexSignature *> *indexSignatures, bool hasSuperClass,
+                                             bool isDeclare, bool isAbstractClass)
+{
+    ClassElmentDescriptor desc;
+
+    desc.methodKind = ir::MethodDefinitionKind::METHOD;
+    desc.newStatus = ParserStatus::ALLOW_SUPER;
+    desc.hasSuperClass = hasSuperClass;
+    desc.propStart = lexer_->GetToken().Start();
+
+    auto decorators = ParseDecorators();
+
+    desc.modifiers = ParseModifiers();
+
+    if ((desc.modifiers & ir::ModifierFlags::ABSTRACT) && !isAbstractClass) {
+        ThrowSyntaxError("Abstract methods can only appear within an abstract class.");
+    }
+
+    CheckClassPrivateIdentifier(&desc);
+    CheckClassGeneratorMethod(&desc);
+    ParseClassKeyModifiers(&desc);
+
+    if (!(desc.modifiers & ir::ModifierFlags::STATIC)) {
+        context_.Status() |= ParserStatus::ALLOW_THIS_TYPE;
+    }
+
+    ir::Expression *propName = ParseClassKey(&desc);
+
+    if (desc.methodKind == ir::MethodDefinitionKind::CONSTRUCTOR && !decorators.empty()) {
+        ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
+    }
+
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
+        if (desc.isIndexSignature) {
+            ThrowSyntaxError("';' expected");
+        }
+
+        if (desc.methodKind == ir::MethodDefinitionKind::CONSTRUCTOR) {
+            ThrowSyntaxError("'(' expected");
+        }
+
+        desc.modifiers |= ir::ModifierFlags::OPTIONAL;
+        lexer_->NextToken();
+    } else if (Extension() == ScriptExtension::TS &&
+               lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK) {
+        if (desc.isIndexSignature || lexer_->Lookahead() != LEX_CHAR_COLON) {
+            ThrowSyntaxError("';' expected");
+        }
+
+        desc.modifiers |= ir::ModifierFlags::DEFINITE;
+        lexer_->NextToken();
+    }
+
+    ir::Expression *typeAnnotation = ParseClassKeyAnnotation();
+
+    ir::Statement *property = nullptr;
+    if (desc.isIndexSignature) {
+        if (!decorators.empty()) {
+            ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
+        }
+
+        if (!typeAnnotation) {
+            ThrowSyntaxError("An index signature must have a type annotation");
+        }
+
+        auto *indexSignature =
+            AllocNode<ir::TSIndexSignature>(propName, typeAnnotation, desc.modifiers & ir::ModifierFlags::READONLY);
+
+        indexSignature->SetRange({indexSignature->Param()->Start(), indexSignature->TypeAnnotation()->End()});
+
+        indexSignatures->push_back(indexSignature);
+
+        property = AllocNode<ir::EmptyStatement>();
+    } else {
+        ValidateClassMethodStart(&desc, typeAnnotation);
+        property = ParseClassProperty(&desc, properties, propName, typeAnnotation, std::move(decorators),
+                                      isDeclare || (desc.modifiers & ir::ModifierFlags::DECLARE));
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON &&
+        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE &&
+        !(lexer_->GetToken().Flags() & lexer::TokenFlags::NEW_LINE) &&
+        !(property->IsMethodDefinition() && property->AsMethodDefinition()->Value()->Function()->Body())) {
+        ThrowSyntaxError("';' expected.");
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+    }
+
+    context_.Status() &= ~ParserStatus::ALLOW_THIS_TYPE;
+
+    return property;
+}
+
+static bool IsConstructor(ir::Statement *stmt)
+{
+    if (!stmt->IsMethodDefinition()) {
+        return false;
+    }
+
+    ir::MethodDefinition *def = stmt->AsMethodDefinition();
+    return def->Kind() == ir::MethodDefinitionKind::CONSTRUCTOR;
+}
+
+ir::MethodDefinition *ParserImpl::CreateImplicitConstructor(bool hasSuperClass)
+{
+    ArenaVector<ir::Expression *> params(Allocator()->Adapter());
+    ArenaVector<ir::Statement *> statements(Allocator()->Adapter());
+
+    auto *paramScope = Binder()->Allocator()->New<binder::FunctionParamScope>(Allocator(), Binder()->GetScope());
+    auto *scope = Binder()->Allocator()->New<binder::FunctionScope>(Allocator(), paramScope);
+
+    if (hasSuperClass) {
+        util::StringView argsStr = "args";
+        params.push_back(AllocNode<ir::SpreadElement>(ir::AstNodeType::REST_ELEMENT,
+                                                      AllocNode<ir::Identifier>(argsStr, Allocator())));
+        paramScope->AddParamDecl(Allocator(), params.back());
+
+        ArenaVector<ir::Expression *> callArgs(Allocator()->Adapter());
+        auto *superExpr = AllocNode<ir::SuperExpression>();
+        callArgs.push_back(AllocNode<ir::SpreadElement>(ir::AstNodeType::SPREAD_ELEMENT,
+                                                        AllocNode<ir::Identifier>(argsStr, Allocator())));
+
+        auto *callExpr = AllocNode<ir::CallExpression>(superExpr, std::move(callArgs), nullptr, false);
+        statements.push_back(AllocNode<ir::ExpressionStatement>(callExpr));
+    }
+
+    auto *body = AllocNode<ir::BlockStatement>(scope, std::move(statements));
+    auto *func = AllocNode<ir::ScriptFunction>(scope, std::move(params), nullptr, body, nullptr,
+                                               ir::ScriptFunctionFlags::CONSTRUCTOR, false);
+    scope->BindNode(func);
+    paramScope->BindNode(func);
+    scope->BindParamScope(paramScope);
+    paramScope->BindFunctionScope(scope);
+
+    auto *funcExpr = AllocNode<ir::FunctionExpression>(func);
+    auto *key = AllocNode<ir::Identifier>("constructor", Allocator());
+
+    ArenaVector<ir::Decorator *> decorators(Allocator()->Adapter());
+
+    auto *ctor = AllocNode<ir::MethodDefinition>(ir::MethodDefinitionKind::CONSTRUCTOR, key, funcExpr,
+                                                 ir::ModifierFlags::NONE, Allocator(), std::move(decorators), false);
+
+    return ctor;
+}
+
+bool ParserImpl::IsPropertyKeysAreSame(const ir::Expression *exp1, const ir::Expression *exp2)
+{
+    if (exp1->IsIdentifier() && exp2->IsIdentifier()) {
+        return exp1->AsIdentifier()->Name() == exp2->AsIdentifier()->Name();
+    }
+
+    if (exp1->IsIdentifier() && exp2->IsStringLiteral()) {
+        return exp1->AsIdentifier()->Name() == exp2->AsStringLiteral()->Str();
+    }
+
+    if (exp1->IsStringLiteral() && exp2->IsStringLiteral()) {
+        return *exp1->AsStringLiteral() == *exp2->AsStringLiteral();
+    }
+
+    if (exp1->IsStringLiteral() && exp2->IsIdentifier()) {
+        return exp1->AsStringLiteral()->Str() == exp2->AsIdentifier()->Name();
+    }
+
+    if (exp1->IsStringLiteral() && exp2->IsNumberLiteral()) {
+        std::string exp2String = std::to_string(exp2->AsNumberLiteral()->Number<double>());
+        exp2String.erase(exp2String.find_last_not_of('0'), std::string::npos);
+        return exp1->AsStringLiteral()->Str().Utf8() == exp2String;
+    }
+
+    if (exp1->IsNumberLiteral() && exp2->IsNumberLiteral()) {
+        return exp1->AsNumberLiteral()->Number<double>() == exp2->AsNumberLiteral()->Number<double>();
+    }
+
+    if (exp1->IsNumberLiteral() && exp2->IsStringLiteral()) {
+        std::string exp1String = std::to_string(exp1->AsNumberLiteral()->Number<double>());
+        exp1String.erase(exp1String.find_last_not_of('0'), std::string::npos);
+        return exp1String == exp2->AsStringLiteral()->Str().Utf8();
+    }
+
+    return false;
+}
+
+bool ParserImpl::IsMemberExpressionsAreSame(const ir::MemberExpression *mExp1, const ir::MemberExpression *mExp2)
+{
+    if (!IsPropertyKeysAreSame(mExp1->Property(), mExp2->Property())) {
+        return false;
+    }
+
+    if (mExp1->Object()->IsMemberExpression() && mExp2->Object()->IsMemberExpression()) {
+        return IsMemberExpressionsAreSame(mExp1->Object()->AsMemberExpression(), mExp2->Object()->AsMemberExpression());
+    }
+
+    return IsPropertyKeysAreSame(mExp1->Object(), mExp2->Object());
+}
+
+bool ParserImpl::IsMethodDefinitionsAreSame(const ir::MethodDefinition *property, ir::MethodDefinition *overload)
+{
+    if (property->Kind() != overload->Kind() || property->IsStatic() != overload->IsStatic()) {
+        return false;
+    }
+
+    if (property->Key()->IsMemberExpression() && overload->Key()->IsMemberExpression()) {
+        return IsMemberExpressionsAreSame(property->Key()->AsMemberExpression(), overload->Key()->AsMemberExpression());
+    }
+
+    return IsPropertyKeysAreSame(property->Key(), overload->Key());
+}
+
+ir::Identifier *ParserImpl::SetIdentNodeInClassDefinition()
+{
+    lexer::TokenType keywType = lexer_->GetToken().KeywordType();
+    if (keywType >= lexer::TokenType::KEYW_STATIC) {
+        ThrowSyntaxError("Unexpected reserved word");
+    }
+
+    if (keywType == lexer::TokenType::KEYW_AWAIT && context_.IsModule()) {
+        ThrowSyntaxError("Unexpected reserved word");
+    }
+
+    const util::StringView &identStr = lexer_->GetToken().Ident();
+
+    Binder()->AddDecl<binder::ConstDecl>(lexer_->GetToken().Start(), identStr);
+
+    auto *identNode = AllocNode<ir::Identifier>(identStr, Allocator());
+    identNode->SetRange(lexer_->GetToken().Loc());
+
+    lexer_->NextToken();
+
+    return identNode;
+}
+
+ir::ClassDefinition *ParserImpl::ParseClassDefinition(bool isDeclaration, bool idRequired, bool isDeclare,
+                                                      bool isAbstract)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+
+    ir::Identifier *identNode = nullptr;
+
+    auto classCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT) {
+        identNode = SetIdentNodeInClassDefinition();
+    } else if (isDeclaration && idRequired) {
+        ThrowSyntaxError("Unexpected token, expected an identifier.");
+    }
+
+    ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        typeParamDecl = ParseTsTypeParameterDeclaration();
+    }
+
+    // Parse SuperClass
+    ir::Expression *superClass = nullptr;
+    bool hasSuperClass = false;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_EXTENDS) {
+        lexer_->NextToken();
+        hasSuperClass = true;
+        superClass = ParseLeftHandSideExpression();
+    }
+
+    ir::TSTypeParameterInstantiation *superTypeParams = nullptr;
+    if (Extension() == ScriptExtension::TS && (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN ||
+                                               lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT)) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT) {
+            lexer_->BackwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
+        }
+
+        superTypeParams = ParseTsTypeParameterInstantiation();
+    }
+
+    ArenaVector<ir::TSClassImplements *> implements(Allocator()->Adapter());
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_IMPLEMENTS) {
+        lexer_->NextToken();
+
+        while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+            lexer::SourcePosition implStart = lexer_->GetToken().Start();
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+                ThrowSyntaxError("Identifier expected");
+            }
+
+            ir::Expression *expr = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+            expr->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+                expr = ParseTsQualifiedReference(expr);
+            }
+
+            ir::TSTypeParameterInstantiation *implTypeParams = nullptr;
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT) {
+                lexer_->BackwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
+            }
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN ||
+                lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT) {
+                implTypeParams = ParseTsTypeParameterInstantiation();
+            }
+
+            auto *impl = AllocNode<ir::TSClassImplements>(expr, implTypeParams);
+            impl->SetRange({implStart, lexer_->GetToken().End()});
+            implements.push_back(impl);
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+                lexer_->NextToken();
+                continue;
+            }
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+                ThrowSyntaxError("',' expected");
+            }
+        }
+
+        if (implements.empty()) {
+            ThrowSyntaxError("Implements clause can not be empty");
+        }
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        ThrowSyntaxError("Unexpected token, expected '{'");
+    }
+
+    // Parse ClassBody
+    auto savedStatus = context_.Status();
+    context_.Status() |= ParserStatus::IN_CLASS_BODY;
+    lexer::SourcePosition classBodyStartLoc = lexer_->GetToken().Start();
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+
+    ir::MethodDefinition *ctor = nullptr;
+    ArenaVector<ir::Statement *> properties(Allocator()->Adapter());
+    ArenaVector<ir::TSIndexSignature *> indexSignatures(Allocator()->Adapter());
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+            lexer_->NextToken();
+            continue;
+        }
+
+        ir::Statement *property = ParseClassElement(properties, &indexSignatures, hasSuperClass, isDeclare, isAbstract);
+
+        if (property->IsEmptyStatement()) {
+            continue;
+        }
+
+        if (IsConstructor(property)) {
+            if (ctor) {
+                ThrowSyntaxError("Multiple constructor implementations are not allowed.", property->Start());
+            }
+            ctor = property->AsMethodDefinition();
+            continue;
+        }
+
+        properties.push_back(property);
+    }
+
+    context_.Status() = savedStatus;
+
+    lexer::SourcePosition classBodyEndLoc = lexer_->GetToken().End();
+    if (ctor == nullptr) {
+        ctor = CreateImplicitConstructor(hasSuperClass);
+        ctor->SetRange({startLoc, classBodyEndLoc});
+    }
+    lexer_->NextToken();
+
+    auto *classDefinition = AllocNode<ir::ClassDefinition>(
+        classCtx.GetScope(), identNode, typeParamDecl, superTypeParams, std::move(implements), ctor, superClass,
+        std::move(properties), std::move(indexSignatures), isDeclare, isAbstract);
+
+    classDefinition->SetRange({classBodyStartLoc, classBodyEndLoc});
+
+    return classDefinition;
+}
+
+ir::TSEnumDeclaration *ParserImpl::ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart,
+                                                    bool isConst)
+{
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        ThrowSyntaxError("'{' expected");
+    }
+
+    ArenaVector<ir::TSEnumMember *> members(Allocator()->Adapter());
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat '{'
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ir::Expression *memberKey = nullptr;
+        const auto &keyStartLoc = lexer_->GetToken().Start();
+        binder::EnumDecl *decl {};
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT) {
+            memberKey = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+            decl = Binder()->AddDecl<binder::EnumDecl>(keyStartLoc, lexer_->GetToken().Ident());
+            memberKey->SetRange(lexer_->GetToken().Loc());
+            lexer_->NextToken();
+        } else if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING) {
+            decl = Binder()->AddDecl<binder::EnumDecl>(keyStartLoc, lexer_->GetToken().String());
+            memberKey = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+            memberKey->SetRange(lexer_->GetToken().Loc());
+            lexer_->NextToken();
+        } else {
+            ThrowSyntaxError("Unexpected token in enum member");
+        }
+
+        ir::Expression *memberInit = nullptr;
+        lexer::SourcePosition initStart = lexer_->GetToken().Start();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+            lexer_->NextToken();  // eat '='
+            initStart = lexer_->GetToken().Start();
+            memberInit = ParseExpression();
+        }
+
+        auto *member = AllocNode<ir::TSEnumMember>(memberKey, memberInit);
+        decl->BindNode(member);
+        member->SetRange({initStart, lexer_->GetToken().End()});
+        members.push_back(member);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat ','
+        }
+    }
+
+    auto *enumDeclaration =
+        AllocNode<ir::TSEnumDeclaration>(Binder()->GetScope()->AsLocalScope(), key, std::move(members), isConst);
+    enumDeclaration->SetRange({enumStart, lexer_->GetToken().End()});
+    Binder()->GetScope()->BindNode(enumDeclaration);
+    lexer_->NextToken();  // eat '}'
+
+    return enumDeclaration;
+}
+
+ir::TSEnumDeclaration *ParserImpl::ParseEnumDeclaration(bool isConst)
+{
+    ASSERT(lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ENUM);
+    lexer::SourcePosition enumStart = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat enum keyword
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Identifier expected");
+    }
+
+    const util::StringView &ident = lexer_->GetToken().Ident();
+    binder::TSBinding tsBinding(Allocator(), ident);
+
+    auto *key = AllocNode<ir::Identifier>(ident, Allocator());
+    key->SetRange(lexer_->GetToken().Loc());
+    lexer_->NextToken();
+
+    const auto &bindings = Binder()->GetScope()->Bindings();
+    auto res = bindings.find(tsBinding.View());
+    binder::EnumLiteralDecl *decl {};
+
+    if (res == bindings.end()) {
+        decl = Binder()->AddTsDecl<binder::EnumLiteralDecl>(lexer_->GetToken().Start(), tsBinding.View(), isConst);
+        binder::LexicalScope enumCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+        decl->AsEnumLiteralDecl()->BindScope(enumCtx.GetScope());
+        return ParseEnumMembers(key, enumStart, isConst);
+    }
+
+    if (!res->second->Declaration()->IsEnumLiteralDecl() ||
+        (isConst ^ res->second->Declaration()->AsEnumLiteralDecl()->IsConst())) {
+        Binder()->ThrowRedeclaration(lexer_->GetToken().Start(), ident);
+    }
+
+    decl = res->second->Declaration()->AsEnumLiteralDecl();
+
+    auto scopeCtx = binder::LexicalScope<binder::LocalScope>::Enter(Binder(), decl->Scope());
+    return ParseEnumMembers(key, enumStart, isConst);
+}
+
+void ParserImpl::ValidateFunctionParam(const ArenaVector<ir::Expression *> &params, const ir::Expression *parameter,
+                                       bool *seenOptional)
+{
+    if (!parameter->IsIdentifier()) {
+        context_.Status() |= ParserStatus::HAS_COMPLEX_PARAM;
+        if (!parameter->IsRestElement()) {
+            return;
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+            const char *msg = (Extension() == ScriptExtension::JS ? "Rest parameter must be last formal parameter"
+                                                                  : "A rest parameter must be last in parameter list");
+            ThrowSyntaxError(msg);
+        }
+        return;
+    }
+
+    if (Extension() != ScriptExtension::TS) {
+        return;
+    }
+
+    bool currentIsOptinal = parameter->AsIdentifier()->IsOptional();
+    if (*seenOptional && !currentIsOptinal) {
+        ThrowSyntaxError("A required parameter cannot follow an optional parameter");
+    }
+
+    *seenOptional |= currentIsOptinal;
+    const util::StringView &paramName = parameter->AsIdentifier()->Name();
+
+    if (paramName.Is("this")) {
+        if (!params.empty()) {
+            ThrowSyntaxError("A 'this' parameter must be the first parameter");
+        }
+
+        if (context_.Status() & ParserStatus::CONSTRUCTOR_FUNCTION) {
+            ThrowSyntaxError("A constructor cannot have a 'this' parameter");
+        }
+
+        if (context_.Status() & ParserStatus::ARROW_FUNCTION) {
+            ThrowSyntaxError("An arrow function cannot have a 'this' parameter");
+        }
+
+        if (context_.Status() & ParserStatus::ACCESSOR_FUNCTION) {
+            ThrowSyntaxError("'get' and 'set' accessors cannot declare 'this' parameters");
+        }
+    }
+
+    if (paramName.Is("constructor") && (context_.Status() & ParserStatus::CONSTRUCTOR_FUNCTION)) {
+        ThrowSyntaxError("'constructor' cannot be used as a parameter property name");
+    }
+}
+
+ArenaVector<ir::Expression *> ParserImpl::ParseFunctionParams(bool isDeclare)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS);
+    lexer_->NextToken();
+
+    ArenaVector<ir::Expression *> params(Allocator()->Adapter());
+    bool seenOptional = false;
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ir::Expression *parameter = ParseFunctionParameter(isDeclare);
+        ValidateFunctionParam(params, parameter, &seenOptional);
+
+        params.push_back(parameter);
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA &&
+            lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+            ThrowSyntaxError(", expected");
+        }
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            lexer_->NextToken();
+        }
+    }
+
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS);
+    lexer_->NextToken();
+
+    return params;
+}
+
+bool ParserImpl::CheckTypeNameIsReserved(const util::StringView &paramName)
+{
+    return paramName.Is("number") || paramName.Is("any") || paramName.Is("unknown") || paramName.Is("never") ||
+           paramName.Is("bigint") || paramName.Is("boolean") || paramName.Is("string") || paramName.Is("string") ||
+           paramName.Is("void") || paramName.Is("object");
+}
+
+ir::TSTypeParameter *ParserImpl::ParseTsTypeParameter(bool throwError, bool addBinding)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        if (!throwError) {
+            return nullptr;
+        }
+
+        ThrowSyntaxError("Type parameter declaration expected");
+    }
+
+    const auto &ident = lexer_->GetToken().Ident();
+
+    if (CheckTypeNameIsReserved(ident)) {
+        if (!throwError) {
+            return nullptr;
+        }
+
+        ThrowSyntaxError("Invalid type parameter name");
+    }
+
+    auto *paramIdent = AllocNode<ir::Identifier>(ident, Allocator());
+
+    if (addBinding) {
+        Binder()->AddDecl<binder::LetDecl>(lexer_->GetToken().Start(), ident);
+    }
+
+    paramIdent->SetRange({lexer_->GetToken().Start(), lexer_->GetToken().End()});
+
+    lexer_->NextToken();
+
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::NO_OPTS;
+
+    if (throwError) {
+        options |= TypeAnnotationParsingOptions::THROW_ERROR;
+    }
+
+    ir::Expression *constraint = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_EXTENDS) {
+        lexer_->NextToken();
+        constraint = ParseTsTypeAnnotation(&options);
+    }
+
+    ir::Expression *defaultType = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        lexer_->NextToken();
+        defaultType = ParseTsTypeAnnotation(&options);
+    }
+
+    auto *typeParam = AllocNode<ir::TSTypeParameter>(paramIdent, constraint, defaultType);
+
+    typeParam->SetRange({startLoc, lexer_->GetToken().End()});
+
+    return typeParam;
+}
+
+ir::TSTypeParameterDeclaration *ParserImpl::ParseTsTypeParameterDeclaration(bool throwError)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN);
+
+    auto localCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    ArenaVector<ir::TSTypeParameter *> params(Allocator()->Adapter());
+    bool seenDefault = false;
+    size_t requiredParams = 0;
+    lexer_->NextToken();  // eat '<'
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_GREATER_THAN) {
+        ir::TSTypeParameter *currentParam = ParseTsTypeParameter(throwError, true);
+
+        if (!currentParam) {
+            ASSERT(!throwError);
+            return nullptr;
+        }
+
+        if (currentParam->DefaultType()) {
+            seenDefault = true;
+        } else if (seenDefault) {
+            ThrowSyntaxError("Required type parameters may not follow optional type parameters.");
+        } else {
+            requiredParams++;
+        }
+
+        params.push_back(currentParam);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            lexer_->NextToken();
+            continue;
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_GREATER_THAN) {
+            if (!throwError) {
+                return nullptr;
+            }
+
+            ThrowSyntaxError("'>' expected");
+        }
+    }
+
+    if (params.empty()) {
+        ThrowSyntaxError("Type parameter list cannot be empty.");
+    }
+
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();  // eat '>'
+
+    auto *typeParamDecl =
+        AllocNode<ir::TSTypeParameterDeclaration>(localCtx.GetScope(), std::move(params), requiredParams);
+    typeParamDecl->SetRange({startLoc, endLoc});
+    localCtx.GetScope()->BindNode(typeParamDecl);
+
+    return typeParamDecl;
+}
+
+ir::TSTypeParameterInstantiation *ParserImpl::ParseTsTypeParameterInstantiation(bool throwError)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN);
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    ArenaVector<ir::Expression *> params(Allocator()->Adapter());
+    lexer_->NextToken();  // eat '<'
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_GREATER_THAN) {
+        TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::NO_OPTS;
+
+        if (throwError) {
+            options |= TypeAnnotationParsingOptions::THROW_ERROR;
+        }
+
+        ir::Expression *currentParam = ParseTsTypeAnnotation(&options);
+
+        if (!currentParam) {
+            return nullptr;
+        }
+
+        params.push_back(currentParam);
+
+        switch (lexer_->GetToken().Type()) {
+            case lexer::TokenType::PUNCTUATOR_COMMA: {
+                lexer_->NextToken();
+                continue;
+            }
+            case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT: {
+                lexer_->BackwardToken(lexer::TokenType::PUNCTUATOR_GREATER_THAN, 1);
+                break;
+            }
+            case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT: {
+                lexer_->BackwardToken(lexer::TokenType::PUNCTUATOR_GREATER_THAN, 2);
+                break;
+            }
+            case lexer::TokenType::PUNCTUATOR_GREATER_THAN: {
+                break;
+            }
+            default: {
+                if (throwError) {
+                    ThrowSyntaxError("'>' expected");
+                }
+
+                return nullptr;
+            }
+        }
+    }
+
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();
+
+    auto *typeParamInst = AllocNode<ir::TSTypeParameterInstantiation>(std::move(params));
+
+    typeParamInst->SetRange({startLoc, endLoc});
+
+    return typeParamInst;
+}
+
+ir::ScriptFunction *ParserImpl::ParseFunction(ParserStatus newStatus, bool isDeclare)
+{
+    FunctionContext functionContext(this, newStatus | ParserStatus::FUNCTION | ParserStatus::ALLOW_NEW_TARGET);
+
+    FunctionParameterContext funcParamContext(&context_, Binder());
+    auto *funcParamScope = funcParamContext.LexicalScope().GetScope();
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        typeParamDecl = ParseTsTypeParameterDeclaration();
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token, expected '('");
+    }
+
+    if (newStatus & (ParserStatus::ASYNC_FUNCTION | ParserStatus::FUNCTION_DECLARATION)) {
+        context_.Status() |= ParserStatus::DISALLOW_AWAIT;
+    }
+
+    ArenaVector<ir::Expression *> params = ParseFunctionParams(isDeclare);
+
+    ir::Expression *returnTypeAnnotation = nullptr;
+
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+        lexer_->NextToken();  // eat ':'
+        TypeAnnotationParsingOptions options =
+            TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::CAN_BE_TS_TYPE_PREDICATE;
+        returnTypeAnnotation = ParseTsTypeAnnotation(&options);
+    }
+
+    auto functionCtx = binder::LexicalScope<binder::FunctionScope>(Binder());
+    auto *functionScope = functionCtx.GetScope();
+    functionScope->BindParamScope(funcParamScope);
+    funcParamScope->BindFunctionScope(functionScope);
+
+    ir::BlockStatement *body = nullptr;
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    bool letDeclare = true;
+
+    if (newStatus & ParserStatus::ASYNC_FUNCTION) {
+        context_.Status() &= ~ParserStatus::DISALLOW_AWAIT;
+    } else {
+        context_.Status() |= ParserStatus::DISALLOW_AWAIT;
+    }
+
+    if (newStatus & ParserStatus::GENERATOR_FUNCTION) {
+        context_.Status() |= ParserStatus::ALLOW_YIELD;
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        if (Extension() == ScriptExtension::TS && (newStatus & ParserStatus::FUNCTION_DECLARATION)) {
+            ValidateTsFunctionOverloadParams(params);
+            functionContext.AddFlag(ir::ScriptFunctionFlags::OVERLOAD);
+        } else if (!isDeclare && !(context_.Status() & ParserStatus::IN_METHOD_DEFINITION)) {
+            ThrowSyntaxError("Unexpected token, expected '{'");
+        } else {
+            letDeclare = false;
+            functionContext.AddFlag(ir::ScriptFunctionFlags::OVERLOAD);
+        }
+    } else if (isDeclare) {
+        ThrowSyntaxError("An implementation cannot be declared in ambient contexts.");
+    } else {
+        body = ParseBlockStatement(functionScope);
+        endLoc = body->End();
+    }
+
+    auto *funcNode =
+        AllocNode<ir::ScriptFunction>(functionScope, std::move(params), typeParamDecl, body, returnTypeAnnotation,
+                                      functionContext.Flags(), isDeclare && letDeclare);
+    functionScope->BindNode(funcNode);
+    funcParamScope->BindNode(funcNode);
+    funcNode->SetRange({startLoc, endLoc});
+
+    return funcNode;
+}
+
+void ParserImpl::ValidateTsFunctionOverloadParams(const ArenaVector<ir::Expression *> &params)
+{
+    for (auto *it : params) {
+        if (it->IsAssignmentPattern()) {
+            ThrowSyntaxError(
+                "A parameter initializer is only allowed in a function "
+                "or constructor implementation.",
+                it->Start());
+        }
+    }
+}
+
+ir::SpreadElement *ParserImpl::ParseSpreadElement(ExpressionParseFlags flags)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD_PERIOD_PERIOD);
+    lexer::SourcePosition startLocation = lexer_->GetToken().Start();
+    bool inPattern = (flags & ExpressionParseFlags::MUST_BE_PATTERN);
+    lexer_->NextToken();
+
+    ir::Expression *argument {};
+    if (inPattern) {
+        argument = ParsePatternElement(ExpressionParseFlags::IN_REST);
+        if ((flags & ExpressionParseFlags::OBJECT_PATTERN) && !argument->IsIdentifier()) {
+            ThrowSyntaxError("RestParameter must be followed by an identifier in declaration contexts");
+        }
+    } else {
+        argument = ParseExpression(flags);
+    }
+
+    ir::Expression *typeAnnotation = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+        lexer_->NextToken();  // eat ':'
+        TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+        typeAnnotation = ParseTsTypeAnnotation(&options);
+    }
+
+    if (inPattern && argument->IsAssignmentExpression()) {
+        ThrowSyntaxError("RestParameter does not support an initializer");
+    }
+
+    lexer::SourcePosition endLoc = typeAnnotation ? typeAnnotation->End() : argument->End();
+
+    auto nodeType = inPattern ? ir::AstNodeType::REST_ELEMENT : ir::AstNodeType::SPREAD_ELEMENT;
+    auto *spreadElementNode = AllocNode<ir::SpreadElement>(nodeType, argument);
+    spreadElementNode->SetRange({startLocation, endLoc});
+
+    if (typeAnnotation) {
+        spreadElementNode->SetTsTypeAnnotation(typeAnnotation);
+    }
+
+    return spreadElementNode;
+}
+
+ir::TSParameterProperty *ParserImpl::CreateTsParameterProperty(ir::Expression *parameter, ir::ModifierFlags modifiers)
+{
+    auto accessibility = ir::AccessibilityOption::NO_OPTS;
+    bool readonly = false;
+    bool isStatic = false;
+    bool isExport = false;
+
+    if (modifiers & ir::ModifierFlags::PRIVATE) {
+        accessibility = ir::AccessibilityOption::PRIVATE;
+    } else if ((modifiers & ir::ModifierFlags::PUBLIC)) {
+        accessibility = ir::AccessibilityOption::PUBLIC;
+    } else if (modifiers & ir::ModifierFlags::PROTECTED) {
+        accessibility = ir::AccessibilityOption::PROTECTED;
+    }
+
+    if (modifiers & ir::ModifierFlags::READONLY) {
+        readonly = true;
+    }
+
+    if (modifiers & ir::ModifierFlags::STATIC) {
+        isStatic = true;
+    }
+
+    // TODO(Csaba Repasi): Handle export property of TSParameterProperty
+
+    return AllocNode<ir::TSParameterProperty>(accessibility, parameter, readonly, isStatic, isExport);
+}
+
+ir::Expression *ParserImpl::ParseFunctionParameter(bool isDeclare)
+{
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_THIS) {
+        lexer_->GetToken().SetTokenType(lexer::TokenType::LITERAL_IDENT);
+    }
+
+    lexer::SourcePosition parameterStart = lexer_->GetToken().Start();
+    ir::ModifierFlags modifiers = ParseModifiers();
+    // TODO(Csaba Repasi): throw error if using strick mode reserved keyword here
+    if (!(context_.Status() & ParserStatus::CONSTRUCTOR_FUNCTION) && modifiers != ir::ModifierFlags::NONE) {
+        ThrowSyntaxError("A parameter property is only allowed in a constructor implementation.", parameterStart);
+    }
+
+    lexer::TokenType tokenType = lexer_->GetToken().Type();
+    if (tokenType == lexer::TokenType::LITERAL_IDENT &&
+        (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ARGUMENTS ||
+         lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_EVAL)) {
+        ThrowSyntaxError(
+            "'eval' or 'arguments' can't be defined or assigned to "
+            "in strict mode code",
+            lexer_->GetToken().Start());
+    }
+
+    ir::Expression *functionParameter = ParsePatternElement(ExpressionParseFlags::NO_OPTS, true, isDeclare);
+
+    if (modifiers != ir::ModifierFlags::NONE && functionParameter->IsRestElement()) {
+        ThrowSyntaxError("A parameter property cannot be declared using a rest parameter.", parameterStart);
+    }
+
+    if (modifiers != ir::ModifierFlags::NONE &&
+        (functionParameter->IsArrayPattern() || functionParameter->IsObjectPattern() ||
+         (functionParameter->IsAssignmentPattern() &&
+          (functionParameter->AsAssignmentPattern()->Left()->IsArrayPattern() ||
+           functionParameter->AsAssignmentPattern()->Left()->IsObjectPattern())))) {
+        ThrowSyntaxError("A parameter property may not be declared using a binding pattern.", parameterStart);
+    }
+
+    if (modifiers != ir::ModifierFlags::NONE) {
+        functionParameter = CreateTsParameterProperty(functionParameter, modifiers);
+        functionParameter->SetRange({parameterStart, functionParameter->AsTSParameterProperty()->Parameter()->End()});
+    }
+
+    Binder()->AddParamDecl(functionParameter);
+
+    return functionParameter;
+}
+
+void ParserImpl::ValidateLvalueAssignmentTarget(ir::Expression *node)
+{
+    switch (node->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            // Check the prevoius ident keyword type
+            if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ARGUMENTS) {
+                ThrowSyntaxError("Assigning to 'arguments' in strict mode is invalid");
+            } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_EVAL) {
+                ThrowSyntaxError("Assigning to 'eval' in strict mode is invalid");
+            }
+            break;
+        }
+        case ir::AstNodeType::MEMBER_EXPRESSION: {
+            break;
+        }
+        default: {
+            ThrowSyntaxError("Invalid left-hand side in assignment expression");
+        }
+    }
+}
+
+void ParserImpl::ValidateAssignmentTarget(ExpressionParseFlags flags, ir::Expression *node)
+{
+    switch (node->Type()) {
+        case ir::AstNodeType::ARRAY_PATTERN:
+        case ir::AstNodeType::OBJECT_PATTERN: {
+            break;
+        }
+        case ir::AstNodeType::ARRAY_EXPRESSION:
+        case ir::AstNodeType::OBJECT_EXPRESSION: {
+            if (flags & ExpressionParseFlags::POTENTIALLY_IN_PATTERN) {
+                return;
+            }
+
+            [[fallthrough]];
+        }
+        default: {
+            return ValidateLvalueAssignmentTarget(node);
+        }
+    }
+}
+
+void ParserImpl::ValidateArrowParameterBindings(const ir::Expression *node)
+{
+    switch (node->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            const util::StringView &identifier = node->AsIdentifier()->Name();
+
+            if (context_.IsAsync() && identifier.Is("await")) {
+                ThrowSyntaxError("'await' in formal parameter is invalid.", node->Start());
+            }
+            break;
+        }
+        case ir::AstNodeType::OMITTED_EXPRESSION: {
+            break;
+        }
+        case ir::AstNodeType::REST_ELEMENT: {
+            ValidateArrowParameterBindings(node->AsRestElement()->Argument());
+            break;
+        }
+        case ir::AstNodeType::PROPERTY: {
+            break;
+        }
+        case ir::AstNodeType::OBJECT_PATTERN: {
+            const auto &props = node->AsObjectPattern()->Properties();
+
+            for (auto *it : props) {
+                ValidateArrowParameterBindings(it);
+            }
+            break;
+        }
+        case ir::AstNodeType::ARRAY_PATTERN: {
+            const auto &elements = node->AsArrayPattern()->Elements();
+
+            for (auto *it : elements) {
+                ValidateArrowParameterBindings(it);
+            }
+            break;
+        }
+        case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+            ValidateArrowParameterBindings(node->AsAssignmentPattern()->Left());
+            break;
+        }
+        default: {
+            ThrowSyntaxError("Unexpected ArrowParameter element");
+        }
+    }
+}
+
+bool ParserImpl::CurrentTokenIsModifier(char32_t nextCp) const
+{
+    return (Extension() == ScriptExtension::TS &&
+            (nextCp != LEX_CHAR_EQUALS || nextCp != LEX_CHAR_SEMICOLON || nextCp != LEX_CHAR_LEFT_PAREN));
+}
+
+void ParserImpl::ThrowParameterModifierError(ir::ModifierFlags status) const
+{
+    ThrowSyntaxError(
+        {"'", status & ir::ModifierFlags::STATIC ? "static" : status & ir::ModifierFlags::ASYNC ? "async" : "declare",
+         "' modifier cannot appear on a parameter."},
+        lexer_->GetToken().Start());
+}
+
+void ParserImpl::ThrowSyntaxError(std::string_view errorMessage) const
+{
+    ThrowSyntaxError(errorMessage, lexer_->GetToken().Start());
+}
+
+void ParserImpl::ThrowSyntaxError(std::initializer_list<std::string_view> list) const
+{
+    ThrowSyntaxError(list, lexer_->GetToken().Start());
+}
+
+void ParserImpl::ThrowSyntaxError(std::initializer_list<std::string_view> list, const lexer::SourcePosition &pos) const
+{
+    std::stringstream ss;
+
+    for (const auto &it : list) {
+        ss << it;
+    }
+
+    std::string err = ss.str();
+
+    ThrowSyntaxError(std::string_view {err}, pos);
+}
+
+void ParserImpl::ThrowSyntaxError(std::string_view errorMessage, const lexer::SourcePosition &pos) const
+{
+    lexer::LineIndex index(program_.SourceCode());
+    lexer::SourceLocation loc = index.GetLocation(pos);
+
+    throw Error {ErrorType::SYNTAX, errorMessage, loc.line, loc.col};
+}
+
+ScriptExtension ParserImpl::Extension() const
+{
+    return program_.Extension();
+}
+
+void ExportDeclarationContext::BindExportDecl(const ir::AstNode *exportDecl)
+{
+    if (!binder_) {
+        return;
+    }
+
+    binder::ModuleScope::ExportDeclList declList(Allocator()->Adapter());
+
+    if (exportDecl->IsExportDefaultDeclaration()) {
+        const auto *decl = exportDecl->AsExportDefaultDeclaration();
+        const auto *rhs = decl->Decl();
+
+        if (binder_->GetScope()->Bindings().size() == savedBindings_.size()) {
+            if (rhs->IsFunctionDeclaration()) {
+                binder_->AddDecl<binder::FunctionDecl>(rhs->Start(), binder_->Allocator(),
+                                                       util::StringView(DEFAULT_EXPORT),
+                                                       rhs->AsFunctionDeclaration()->Function());
+            } else {
+                binder_->AddDecl<binder::ConstDecl>(rhs->Start(), util::StringView(DEFAULT_EXPORT));
+            }
+        }
+    }
+
+    for (const auto &[name, variable] : binder_->GetScope()->Bindings()) {
+        if (savedBindings_.find(name) != savedBindings_.end()) {
+            continue;
+        }
+
+        util::StringView exportName(exportDecl->IsExportDefaultDeclaration() ? "default" : name);
+
+        variable->AddFlag(binder::VariableFlags::LOCAL_EXPORT);
+        auto *decl = binder_->AddDecl<binder::ExportDecl>(variable->Declaration()->Node()->Start(), exportName, name);
+        declList.push_back(decl);
+    }
+
+    auto *moduleScope = binder_->GetScope()->AsModuleScope();
+    moduleScope->AddExportDecl(exportDecl, std::move(declList));
+}
+
+void ImportDeclarationContext::BindImportDecl(const ir::ImportDeclaration *importDecl)
+{
+    binder::ModuleScope::ImportDeclList declList(Allocator()->Adapter());
+
+    for (const auto &[name, variable] : binder_->GetScope()->Bindings()) {
+        if (savedBindings_.find(name) != savedBindings_.end()) {
+            continue;
+        }
+
+        declList.push_back(variable->Declaration()->AsImportDecl());
+    }
+
+    binder_->GetScope()->AsModuleScope()->AddImportDecl(importDecl, std::move(declList));
+}
+
+}  // namespace panda::es2panda::parser
diff --git a/es2panda/parser/parserImpl.h b/es2panda/parser/parserImpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..e73468a66427f1e910a1fc4261bc6cc2c7e85ebe
--- /dev/null
+++ b/es2panda/parser/parserImpl.h
@@ -0,0 +1,689 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_CORE_PARSER_IMPL_H
+#define ES2PANDA_PARSER_CORE_PARSER_IMPL_H
+
+#include <binder/binder.h>
+#include <es2panda.h>
+#include <ir/astNode.h>
+#include <lexer/token/sourceLocation.h>
+#include <macros.h>
+#include <mem/arena_allocator.h>
+#include <parser/context/parserContext.h>
+#include <parser/parserFlags.h>
+#include <parser/program/program.h>
+#include <util/enumbitops.h>
+#include <util/ustring.h>
+
+#include <memory>
+#include <sstream>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace panda::es2panda::lexer {
+enum class TokenFlags;
+enum class TokenType;
+class LexerPosition;
+class Token;
+class Lexer;
+}  // namespace panda::es2panda::lexer
+
+namespace panda::es2panda::ir {
+class ArrowFunctionExpression;
+class AstNode;
+class BlockStatement;
+class BreakStatement;
+class CallExpression;
+class ClassDeclaration;
+class ClassDefinition;
+class ContinueStatement;
+class DoWhileStatement;
+class ExportAllDeclaration;
+class ExportDefaultDeclaration;
+class ExportNamedDeclaration;
+class ExportNamedDeclaration;
+class Expression;
+class FunctionDeclaration;
+class FunctionExpression;
+class Identifier;
+class IfStatement;
+class ImportDeclaration;
+class LabelledStatement;
+class NewExpression;
+class ObjectExpression;
+class ReturnStatement;
+class ScriptFunction;
+class SequenceExpression;
+class SpreadElement;
+class Statement;
+class StringLiteral;
+class SwitchCaseStatement;
+class SwitchStatement;
+class TSArrayType;
+class TSEnumDeclaration;
+class TSFunctionType;
+class TSInterfaceDeclaration;
+class TSIntersectionType;
+class TSTupleType;
+class TSTypeAliasDeclaration;
+class TSUnionType;
+class TSImportType;
+class TemplateLiteral;
+class ThrowStatement;
+class TryStatement;
+class VariableDeclaration;
+class WhileStatement;
+class WithStatement;
+class TSTypeParameter;
+class TSTypeParameterDeclaration;
+class MemberExpression;
+class MethodDefinition;
+class TSTypeReference;
+class TSMappedType;
+class TSTypePredicate;
+class Decorator;
+class TSIndexSignature;
+class Property;
+class TSTypeParameterInstantiation;
+class TSParameterProperty;
+class TSTypeAssertion;
+class TSAsExpression;
+class YieldExpression;
+class MetaProperty;
+class TSModuleDeclaration;
+class TSImportEqualsDeclaration;
+class TSModuleBlock;
+class EmptyStatement;
+class DebuggerStatement;
+class CatchClause;
+class VariableDeclarator;
+
+enum class PropertyKind;
+enum class TSTupleKind;
+enum class MethodDefinitionKind;
+enum class ModifierFlags;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::parser {
+
+class Program;
+class ParserContext;
+
+class ClassElmentDescriptor {
+public:
+    ir::MethodDefinitionKind methodKind {};
+    ParserStatus newStatus {};
+    ir::ModifierFlags modifiers {};
+    lexer::SourcePosition methodStart {};
+    lexer::SourcePosition propStart {};
+    bool isPrivateIdent {};
+    bool hasSuperClass {};
+    bool isGenerator {};
+    bool invalidComputedProperty {};
+    bool isComputed {};
+    bool isIndexSignature {};
+    bool classMethod {};
+    bool classField {};
+};
+
+class ArrowFunctionDescriptor {
+public:
+    explicit ArrowFunctionDescriptor(ArenaVector<ir::Expression *> &&p, binder::FunctionParamScope *ps,
+                                     lexer::SourcePosition sl, ParserStatus ns)
+        : params(p), paramScope(ps), startLoc(sl), newStatus(ns)
+    {
+    }
+
+    ArenaVector<ir::Expression *> params;
+    binder::FunctionParamScope *paramScope;
+    lexer::SourcePosition startLoc;
+    ParserStatus newStatus;
+};
+
+enum class TypeAnnotationParsingOptions {
+    NO_OPTS = 0,
+    IN_UNION = 1 << 0,
+    ALLOW_CONST = 1 << 1,
+    IN_INTERSECTION = 1 << 2,
+    RESTRICT_EXTENDS = 1 << 3,
+    THROW_ERROR = 1 << 4,
+    CAN_BE_TS_TYPE_PREDICATE = 1 << 5,
+    BREAK_AT_NEW_LINE = 1 << 6,
+};
+
+DEFINE_BITOPS(TypeAnnotationParsingOptions)
+
+class ArrowFunctionContext;
+
+class ParserImpl {
+public:
+    explicit ParserImpl(es2panda::ScriptExtension extension);
+    NO_COPY_SEMANTIC(ParserImpl);
+    NO_MOVE_SEMANTIC(ParserImpl);
+    ~ParserImpl() = default;
+
+    Program ParseScript(const std::string &fileName, const std::string &source);
+    Program ParseModule(const std::string &fileName, const std::string &source);
+
+    ScriptExtension Extension() const;
+
+private:
+    bool IsStartOfMappedType() const;
+    bool IsStartOfTsTypePredicate() const;
+    bool IsStartOfAbstractConstructorType() const;
+
+    bool CurrentTokenIsModifier(char32_t nextCp) const;
+    [[noreturn]] void ThrowParameterModifierError(ir::ModifierFlags status) const;
+    [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage) const;
+    [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list) const;
+    [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list,
+                                       const lexer::SourcePosition &pos) const;
+
+    [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage, const lexer::SourcePosition &pos) const;
+
+    template <typename T, typename... Args>
+    T *AllocNode(Args &&... args)
+    {
+        auto ret = program_.Allocator()->New<T>(std::forward<Args>(args)...);
+        if (ret == nullptr) {
+            throw Error(ErrorType::GENERIC, "Unsuccessful allocation during parsing");
+        }
+        return ret;
+    }
+
+    [[nodiscard]] std::unique_ptr<lexer::Lexer> InitLexer(const std::string &fileName, const std::string &source);
+    void ParseProgram(ScriptKind kind);
+    static ExpressionParseFlags CarryExpressionParserFlag(ExpressionParseFlags origin, ExpressionParseFlags carry);
+    static ExpressionParseFlags CarryPatternFlags(ExpressionParseFlags flags);
+    bool CurrentIsBasicType();
+    bool CurrentLiteralIsBasicType();
+    static bool CheckTypeNameIsReserved(const util::StringView &paramName);
+    static bool IsPropertyKeysAreSame(const ir::Expression *exp1, const ir::Expression *exp2);
+    static bool IsMemberExpressionsAreSame(const ir::MemberExpression *mExp1, const ir::MemberExpression *mExp2);
+    static bool IsMethodDefinitionsAreSame(const ir::MethodDefinition *property, ir::MethodDefinition *overload);
+    ir::TSTypeReference *ParseTsConstExpression();
+    ir::Expression *ParseTsTypeOperatorOrTypeReference();
+    ir::Expression *ParseTsIdentifierReference();
+    ir::Expression *ParseTsBasicType();
+    ir::TSIntersectionType *ParseTsIntersectionType(ir::Expression *type, bool inUnion, bool restrictExtends);
+    ir::TSUnionType *ParseTsUnionType(ir::Expression *type, bool restrictExtends);
+    ir::Expression *ParseTsParenthesizedOrFunctionType(ir::Expression *typeAnnotation, bool throwError);
+    ir::TSArrayType *ParseTsArrayType(ir::Expression *elementType);
+    ir::Expression *ParseTsFunctionType(lexer::SourcePosition startLoc, bool isConstructionType, bool throwError,
+                                        bool abstractConstructor = false);
+    ir::TSTypeParameter *ParseTsMappedTypeParameter();
+    ir::MappedOption ParseMappedOption(lexer::TokenType tokenType);
+    ir::TSMappedType *ParseTsMappedType();
+    ir::TSTypePredicate *ParseTsTypePredicate();
+    ir::Expression *ParseTsTypeLiteralOrInterfaceKey(bool *computed, bool *signature, bool *isIndexSignature);
+    ir::Expression *ParseTsConditionalType(ir::Expression *checkType, bool restrictExtends);
+    ir::Expression *ParseTsTypeLiteralOrInterfaceMember();
+    ArenaVector<ir::Expression *> ParseTsTypeLiteralOrInterface();
+    ir::Expression *ParseTsThisType(bool throwError);
+    ir::Expression *ParseTsIndexAccessType(ir::Expression *typeName);
+    ir::Expression *ParseTsQualifiedReference(ir::Expression *typeName);
+    ir::Expression *ParseTsTypeReferenceOrQuery(bool parseQuery = false);
+    ir::Expression *ParseTsTupleElement(ir::TSTupleKind *kind, bool *seenOptional);
+    ir::TSTupleType *ParseTsTupleType();
+    ir::TSImportType *ParseTsImportType(const lexer::SourcePosition &startLoc, bool isTypeof = false);
+    ir::Expression *ParseTsTypeAnnotation(TypeAnnotationParsingOptions *options);
+    ir::Expression *ParseTsTypeLiteralOrTsMappedType(ir::Expression *typeAnnotation);
+    ir::Expression *ParseTsTypeReferenceOrTsTypePredicate(ir::Expression *typeAnnotation, bool canBeTsTypePredicate);
+    ir::Expression *ParseTsThisTypeOrTsTypePredicate(ir::Expression *typeAnnotation, bool canBeTsTypePredicate,
+                                                     bool throwError);
+    ir::Expression *ParseTsTypeAnnotationElement(ir::Expression *typeAnnotation, TypeAnnotationParsingOptions *options);
+    ir::ModifierFlags ParseModifiers();
+
+    void ThrowIfPrivateIdent(ClassElmentDescriptor *desc, const char *msg);
+    void ValidateClassKey(ClassElmentDescriptor *desc);
+
+    void ValidateClassMethodStart(ClassElmentDescriptor *desc, ir::Expression *typeAnnotation);
+    ir::Expression *ParseClassKey(ClassElmentDescriptor *desc);
+
+    void ValidateClassSetter(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
+                             ir::Expression *propName, ir::ScriptFunction *func, bool hasDecorator,
+                             lexer::SourcePosition errorInfo);
+    void ValidateClassGetter(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
+                             ir::Expression *propName, ir::ScriptFunction *func, bool hasDecorator,
+                             lexer::SourcePosition errorInfo);
+    ir::MethodDefinition *ParseClassMethod(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
+                                           ir::Expression *propName, lexer::SourcePosition *propEnd,
+                                           ArenaVector<ir::Decorator *> &&decorators, bool isDeclare);
+    ir::Statement *ParseClassProperty(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
+                                      ir::Expression *propName, ir::Expression *typeAnnotation,
+                                      ArenaVector<ir::Decorator *> &&decorators, bool isDeclare);
+    void ParseClassKeyModifiers(ClassElmentDescriptor *descy);
+    void CheckClassGeneratorMethod(ClassElmentDescriptor *desc);
+    void CheckClassPrivateIdentifier(ClassElmentDescriptor *desc);
+    ir::Expression *ParseClassKeyAnnotation();
+    ir::Decorator *ParseDecorator();
+    ArenaVector<ir::Decorator *> ParseDecorators();
+    ir::Statement *ParseClassElement(const ArenaVector<ir::Statement *> &properties,
+                                     ArenaVector<ir::TSIndexSignature *> *indexSignatures, bool hasSuperClass,
+                                     bool isDeclare, bool isAbstractClass);
+    ir::MethodDefinition *CreateImplicitConstructor(bool hasSuperClass);
+    ir::MethodDefinition *CheckClassMethodOverload(ir::Statement *property, ir::MethodDefinition **ctor, bool isDeclare,
+                                                   lexer::SourcePosition errorInfo, ir::MethodDefinition *lastOverload,
+                                                   bool implExists, bool isAbstract = false);
+    ir::Identifier *SetIdentNodeInClassDefinition();
+    ir::ClassDefinition *ParseClassDefinition(bool isDeclaration, bool idRequired = true, bool isDeclare = false,
+                                              bool isAbstract = false);
+
+    void ValidateAccessor(ExpressionParseFlags flags, lexer::TokenFlags currentTokenFlags);
+    void CheckPropertyKeyAsycModifier(ParserStatus *methodStatus);
+    ir::Property *ParseShorthandProperty(const lexer::LexerPosition *startPos);
+    void ParseGeneratorPropertyModifier(ExpressionParseFlags flags, ParserStatus *methodStatus);
+    bool ParsePropertyModifiers(ExpressionParseFlags flags, ir::PropertyKind *propertyKind, ParserStatus *methodStatus);
+    ir::Expression *ParsePropertyKey(ExpressionParseFlags flags);
+    ir::Expression *ParsePropertyValue(const ir::PropertyKind *propertyKind, const ParserStatus *methodStatus,
+                                       ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    bool ParsePropertyEnd();
+
+    ir::Expression *ParsePropertyDefinition(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::TSTypeParameter *ParseTsTypeParameter(bool throwError, bool addBinding = false);
+    ir::TSTypeParameterDeclaration *ParseTsTypeParameterDeclaration(bool throwError = true);
+    ir::TSTypeParameterInstantiation *ParseTsTypeParameterInstantiation(bool throwError = true);
+    ir::ScriptFunction *ParseFunction(ParserStatus newStatus = ParserStatus::NO_OPTS, bool isDeclare = false);
+    void ValidateFunctionParam(const ArenaVector<ir::Expression *> &params, const ir::Expression *parameter,
+                               bool *seenOptional);
+    void ValidateTsFunctionOverloadParams(const ArenaVector<ir::Expression *> &params);
+    void CheckAccessorPair(const ArenaVector<ir::Statement *> &properties, const ir::Expression *propName,
+                           ir::MethodDefinitionKind methodKind, ir::ModifierFlags access, bool hasDecorator,
+                           lexer::SourcePosition errorInfo);
+    ArenaVector<ir::Expression *> ParseFunctionParams(bool isDeclare = false);
+    ir::SpreadElement *ParseSpreadElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::TSParameterProperty *CreateTsParameterProperty(ir::Expression *parameter, ir::ModifierFlags modifiers);
+    ir::Expression *ParseFunctionParameter(bool isDeclare);
+
+    // ExpressionParser.Cpp
+
+    ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::ArrowFunctionExpression *ParseTsGenericArrowFunction();
+    ir::TSTypeAssertion *ParseTsTypeAssertion();
+    ir::TSAsExpression *ParseTsAsExpression(ir::Expression *expr, ExpressionParseFlags flags);
+    ir::Expression *ParseArrayExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::YieldExpression *ParseYieldExpression();
+    ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags);
+    ParserStatus ValidateArrowParameter(ir::Expression *expr);
+
+    ArrowFunctionDescriptor ConvertToArrowParameter(ir::Expression *expr, bool isAsync,
+                                                    binder::FunctionParamScope *paramScope);
+    ir::ArrowFunctionExpression *ParseArrowFunctionExpressionBody(ArrowFunctionContext *arrowFunctionContext,
+                                                                  binder::FunctionScope *functionScope,
+                                                                  ArrowFunctionDescriptor *desc,
+                                                                  ir::TSTypeParameterDeclaration *typeParamDecl,
+                                                                  ir::Expression *returnTypeAnnotation);
+    ir::ArrowFunctionExpression *ParseArrowFunctionExpression(ir::Expression *expr,
+                                                              ir::TSTypeParameterDeclaration *typeParamDecl,
+                                                              ir::Expression *returnTypeAnnotation, bool isAsync);
+    ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList();
+    ir::Expression *ParseKeywordExpression();
+    ir::Expression *ParseBinaryExpression(ir::Expression *left);
+    ir::CallExpression *ParseCallExpression(ir::Expression *callee, bool isOptionalChain = false, bool isAsync = false);
+    ir::ArrowFunctionExpression *ParsePotentialArrowExpression(ir::Expression **returnExpression,
+                                                               const lexer::SourcePosition &startLoc);
+
+    void ValidateUpdateExpression(ir::Expression *returnExpression, bool isChainExpression);
+    bool ParsePotentialTsGenericFunctionCall(ir::Expression **returnExpression, const lexer::SourcePosition &startLoc,
+                                             bool ignoreCallExpression);
+    ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
+                                               bool ignoreCallExpression, bool *isChainExpression);
+    ir::Expression *ParseMemberExpression(bool ignoreCallExpression = false,
+                                          ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::ObjectExpression *ParseObjectExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::SequenceExpression *ParseSequenceExpression(ir::Expression *startExpr, bool acceptRest = false,
+                                                    bool acceptTsParam = false);
+    ir::Expression *ParseUnaryOrPrefixUpdateExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::Expression *ParseLeftHandSideExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::MetaProperty *ParsePotentialNewTarget();
+    void CheckInvalidDestructuring(const ir::AstNode *object) const;
+    void ValidateParenthesizedExpression(ir::Expression *lhsExpression);
+    ir::Expression *ParseAssignmentExpression(ir::Expression *expression,
+                                              ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
+    ir::NewExpression *ParseNewExpression();
+    void ParsePotentialTsFunctionParameter(ExpressionParseFlags flags, ir::Expression *returnNode,
+                                           bool isDeclare = false);
+    ir::Expression *ParsePatternElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS,
+                                        bool allowDefault = true, bool isDeclare = false);
+    ir::TemplateLiteral *ParseTemplateLiteral();
+    ir::Expression *ParseImportExpression();
+    ir::FunctionExpression *ParseFunctionExpression(ParserStatus newStatus = ParserStatus::NO_OPTS);
+    ir::Expression *ParseOptionalChain(ir::Expression *leftSideExpr);
+    void ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers);
+    ir::Identifier *ParseNamedImport(const lexer::Token &importedToken);
+
+    ir::StringLiteral *ParseFromClause(bool requireFrom = true);
+    void ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
+    ir::Expression *ParseModuleReference();
+    ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers);
+    ir::AstNode *ParseImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
+    void ValidateAssignmentTarget(ExpressionParseFlags flags, ir::Expression *node);
+    void ValidateLvalueAssignmentTarget(ir::Expression *node);
+    void ValidateArrowParameterBindings(const ir::Expression *node);
+
+    ir::ExportDefaultDeclaration *ParseExportDefaultDeclaration(const lexer::SourcePosition &startLoc,
+                                                                ArenaVector<ir::Decorator *> decorators,
+                                                                bool isExportEquals = false);
+    ir::ExportAllDeclaration *ParseExportAllDeclaration(const lexer::SourcePosition &startLoc);
+    ir::ExportNamedDeclaration *ParseExportNamedSpecifiers(const lexer::SourcePosition &startLoc);
+    ir::ExportNamedDeclaration *ParseNamedExportDeclaration(const lexer::SourcePosition &startLoc,
+                                                            ArenaVector<ir::Decorator *> &&decorators);
+    ir::Identifier *ParseNamedExport(const lexer::Token &exportedToken);
+
+    // StatementParser.Cpp
+
+    void ConsumeSemicolon(ir::Statement *statement);
+    void CheckFunctionDeclaration(StatementParsingFlags flags);
+
+    void CheckLabelledFunction(const ir::Statement *node);
+    void CheckDeclare();
+
+    bool ParseDirective(ArenaVector<ir::Statement *> *statements);
+    void ParseDirectivePrologue(ArenaVector<ir::Statement *> *statements);
+    ArenaVector<ir::Statement *> ParseStatementList(StatementParsingFlags flags = StatementParsingFlags::ALLOW_LEXICAL);
+    ir::Statement *ParseStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
+    ir::TSModuleDeclaration *ParseTsModuleDeclaration(bool isDeclare);
+    ir::TSModuleDeclaration *ParseTsAmbientExternalModuleDeclaration(const lexer::SourcePosition &startLoc,
+                                                                     bool isDeclare);
+    ir::TSModuleDeclaration *ParseTsModuleOrNamespaceDelaration(const lexer::SourcePosition &startLoc, bool isDeclare);
+
+    ir::TSImportEqualsDeclaration *ParseTsImportEqualsDeclaration(const lexer::SourcePosition &startLoc,
+                                                                  bool isExport = false);
+    ir::TSModuleBlock *ParseTsModuleBlock();
+    ir::BlockStatement *ParseFunctionBody();
+    ir::BlockStatement *ParseBlockStatement();
+    ir::BlockStatement *ParseBlockStatement(binder::Scope *scope);
+    ir::EmptyStatement *ParseEmptyStatement();
+    ir::DebuggerStatement *ParseDebuggerStatement();
+    ir::BreakStatement *ParseBreakStatement();
+    ir::ContinueStatement *ParseContinueStatement();
+    ir::DoWhileStatement *ParseDoWhileStatement();
+    ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags, bool isDeclare);
+    ir::Statement *ParseVarStatement(bool isDeclare);
+    ir::Statement *ParseLetStatement(StatementParsingFlags flags, bool isDeclare);
+    ir::Statement *ParseConstStatement(StatementParsingFlags flags, bool isDeclare);
+    ir::Statement *ParseExpressionStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
+    ir::Statement *ParseFunctionStatement(StatementParsingFlags flags, bool isDeclare);
+    ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous = false,
+                                                      ParserStatus newStatus = ParserStatus::NO_OPTS,
+                                                      bool isDeclare = false);
+    ir::Statement *ParseExportDeclaration(StatementParsingFlags flags, ArenaVector<ir::Decorator *> &&decorators);
+    std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseForInOf(
+        ir::Expression *leftNode, ExpressionParseFlags exprFlags, bool isAwait);
+    std::tuple<ForStatementKind, ir::Expression *, ir::Expression *> ParseForInOf(ir::AstNode *initNode,
+                                                                                  ExpressionParseFlags exprFlags,
+                                                                                  bool isAwait);
+    std::tuple<ir::Expression *, ir::Expression *> ParseForUpdate(bool isAwait);
+    ir::Statement *ParseForStatement();
+    ir::IfStatement *ParseIfStatement();
+
+    ir::Statement *ParseImportDeclaration(StatementParsingFlags flags);
+    ir::LabelledStatement *ParseLabelledStatement(const lexer::LexerPosition &pos);
+    ir::ReturnStatement *ParseReturnStatement();
+    ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags, bool isDeclare,
+                                              ArenaVector<ir::Decorator *> &&decorators, bool isAbstract = false);
+    ir::ClassDeclaration *ParseClassDeclaration(bool idRequired, ArenaVector<ir::Decorator *> &&decorators,
+                                                bool isDeclare = false, bool isAbstract = false);
+    ir::TSTypeAliasDeclaration *ParseTsTypeAliasDeclaration(bool isDeclare);
+    ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst);
+    ir::TSEnumDeclaration *ParseEnumDeclaration(bool isConst = false);
+    ir::TSInterfaceDeclaration *ParseTsInterfaceDeclaration();
+    ir::SwitchCaseStatement *ParseSwitchCaseStatement(bool *seenDefault);
+    ir::SwitchStatement *ParseSwitchStatement();
+    ir::ThrowStatement *ParseThrowStatement();
+    ir::Expression *ParseCatchParam();
+    ir::CatchClause *ParseCatchClause();
+    ir::TryStatement *ParseTryStatement();
+    void ValidateDeclaratorId();
+    ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
+                                                               const lexer::SourcePosition &startLoc, bool isDeclare);
+    ir::VariableDeclarator *ParseVariableDeclarator(VariableParsingFlags flags, bool isDeclare);
+    ir::Statement *ParseVariableDeclaration(VariableParsingFlags flags = VariableParsingFlags::NO_OPTS,
+                                            bool isDeclare = false);
+    ir::WhileStatement *ParseWhileStatement();
+    ir::VariableDeclaration *ParseContextualLet(VariableParsingFlags flags,
+                                                StatementParsingFlags stmFlags = StatementParsingFlags::ALLOW_LEXICAL,
+                                                bool isDeclare = false);
+    ArenaAllocator *Allocator() const
+    {
+        return program_.Allocator();
+    }
+
+    binder::Binder *Binder()
+    {
+        return program_.Binder();
+    }
+
+    friend class Lexer;
+    friend class SavedParserContext;
+    friend class ArrowFunctionContext;
+
+    Program program_;
+    ParserContext context_;
+    lexer::Lexer *lexer_ {nullptr};
+};
+
+template <ParserStatus status>
+class SavedStatusContext {
+public:
+    explicit SavedStatusContext(ParserContext *ctx)
+        // NOLINTNEXTLINE(readability-magic-numbers)
+        : ctx_(ctx), savedStatus_(static_cast<ParserStatus>(ctx->Status() & status))
+    {
+        // NOLINTNEXTLINE(readability-magic-numbers)
+        ctx->Status() |= status;
+    }
+
+    NO_COPY_SEMANTIC(SavedStatusContext);
+    NO_MOVE_SEMANTIC(SavedStatusContext);
+
+    ~SavedStatusContext()
+    {
+        if (savedStatus_ == ParserStatus::NO_OPTS) {
+            ctx_->Status() &= ~savedStatus_;
+        }
+    }
+
+private:
+    ParserContext *ctx_;
+    ParserStatus savedStatus_;
+};
+
+class SwitchContext : public SavedStatusContext<ParserStatus::IN_SWITCH> {
+public:
+    explicit SwitchContext(ParserContext *ctx) : SavedStatusContext(ctx) {}
+    NO_COPY_SEMANTIC(SwitchContext);
+    NO_MOVE_SEMANTIC(SwitchContext);
+    ~SwitchContext() = default;
+};
+
+template <typename T>
+class IterationContext : public SavedStatusContext<ParserStatus::IN_ITERATION> {
+public:
+    explicit IterationContext(ParserContext *ctx, binder::Binder *binder)
+        : SavedStatusContext(ctx), lexicalScope_(binder)
+    {
+    }
+
+    NO_COPY_SEMANTIC(IterationContext);
+    NO_MOVE_SEMANTIC(IterationContext);
+    ~IterationContext() = default;
+
+    const auto &LexicalScope() const
+    {
+        return lexicalScope_;
+    }
+
+private:
+    binder::LexicalScope<T> lexicalScope_;
+};
+
+class FunctionParameterContext : public SavedStatusContext<ParserStatus::FUNCTION_PARAM> {
+public:
+    explicit FunctionParameterContext(ParserContext *ctx, binder::Binder *binder)
+        : SavedStatusContext(ctx), lexicalScope_(binder)
+    {
+    }
+
+    const auto &LexicalScope() const
+    {
+        return lexicalScope_;
+    }
+
+    NO_COPY_SEMANTIC(FunctionParameterContext);
+    NO_MOVE_SEMANTIC(FunctionParameterContext);
+    ~FunctionParameterContext() = default;
+
+private:
+    binder::LexicalScope<binder::FunctionParamScope> lexicalScope_;
+};
+
+class SavedParserContext {
+public:
+    template <typename... Args>
+    explicit SavedParserContext(ParserImpl *parser, Args &&... args) : parser_(parser), prev_(parser->context_)
+    {
+        parser_->context_ = ParserContext(&prev_, std::forward<Args>(args)...);
+    }
+
+    NO_COPY_SEMANTIC(SavedParserContext);
+    DEFAULT_MOVE_SEMANTIC(SavedParserContext);
+
+    ~SavedParserContext()
+    {
+        parser_->context_ = prev_;
+    }
+
+protected:
+    binder::Binder *Binder()
+    {
+        return parser_->Binder();
+    }
+
+    ParserImpl *parser_;
+    ParserContext prev_;
+};
+
+class FunctionContext : public SavedParserContext {
+public:
+    explicit FunctionContext(ParserImpl *parser, ParserStatus newStatus) : SavedParserContext(parser, newStatus)
+    {
+        if (newStatus & ParserStatus::GENERATOR_FUNCTION) {
+            flags_ |= ir::ScriptFunctionFlags::GENERATOR;
+        }
+
+        if (newStatus & ParserStatus::ASYNC_FUNCTION) {
+            flags_ |= ir::ScriptFunctionFlags::ASYNC;
+        }
+
+        if (newStatus & ParserStatus::CONSTRUCTOR_FUNCTION) {
+            flags_ |= ir::ScriptFunctionFlags::CONSTRUCTOR;
+        }
+    }
+
+    ir::ScriptFunctionFlags Flags() const
+    {
+        return flags_;
+    }
+
+    void AddFlag(ir::ScriptFunctionFlags flags)
+    {
+        flags_ |= flags;
+    }
+
+    NO_COPY_SEMANTIC(FunctionContext);
+    NO_MOVE_SEMANTIC(FunctionContext);
+    ~FunctionContext() = default;
+
+protected:
+    ir::ScriptFunctionFlags flags_ {ir::ScriptFunctionFlags::NONE};
+};
+
+class ArrowFunctionContext : public FunctionContext {
+public:
+    explicit ArrowFunctionContext(ParserImpl *parser, bool isAsync)
+        : FunctionContext(parser, InitialFlags(parser->context_.Status()))
+    {
+        if (isAsync) {
+            AddFlag(ir::ScriptFunctionFlags::ASYNC);
+        }
+
+        AddFlag(ir::ScriptFunctionFlags::ARROW);
+    }
+
+    NO_COPY_SEMANTIC(ArrowFunctionContext);
+    NO_MOVE_SEMANTIC(ArrowFunctionContext);
+    ~ArrowFunctionContext() = default;
+
+private:
+    static ParserStatus InitialFlags(ParserStatus currentStatus)
+    {
+        return ParserStatus::FUNCTION | ParserStatus::ARROW_FUNCTION |
+               static_cast<ParserStatus>(currentStatus & (ParserStatus::ALLOW_SUPER | ParserStatus::ALLOW_SUPER_CALL));
+    }
+};
+
+class SavedBindingsContext {
+public:
+    explicit SavedBindingsContext(binder::Binder *binder)
+        : binder_(binder), savedBindings_(binder_->GetScope()->Bindings())
+    {
+    }
+    NO_COPY_SEMANTIC(SavedBindingsContext);
+    NO_MOVE_SEMANTIC(SavedBindingsContext);
+    ~SavedBindingsContext() = default;
+
+protected:
+    ArenaAllocator *Allocator() const
+    {
+        return binder_->Allocator();
+    }
+
+    binder::Binder *binder_;
+    binder::VariableMap savedBindings_;
+};
+
+class ExportDeclarationContext : public SavedBindingsContext {
+public:
+    explicit ExportDeclarationContext(binder::Binder *binder) : SavedBindingsContext(binder) {}
+    NO_COPY_SEMANTIC(ExportDeclarationContext);
+    NO_MOVE_SEMANTIC(ExportDeclarationContext);
+    ~ExportDeclarationContext() = default;
+
+    void BindExportDecl(const ir::AstNode *exportDecl);
+
+protected:
+    static constexpr std::string_view DEFAULT_EXPORT = "*default*";
+};
+
+class ImportDeclarationContext : public SavedBindingsContext {
+public:
+    explicit ImportDeclarationContext(binder::Binder *binder) : SavedBindingsContext(binder) {}
+
+    NO_COPY_SEMANTIC(ImportDeclarationContext);
+    NO_MOVE_SEMANTIC(ImportDeclarationContext);
+
+    ~ImportDeclarationContext() = default;
+
+    void BindImportDecl(const ir::ImportDeclaration *importDecl);
+
+private:
+};
+
+}  // namespace panda::es2panda::parser
+
+#endif
diff --git a/es2panda/parser/program/program.cpp b/es2panda/parser/program/program.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..42bee0341657f3772c677b0a7d8125ae637bbb4b
--- /dev/null
+++ b/es2panda/parser/program/program.cpp
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "program.h"
+
+#include <binder/binder.h>
+#include <ir/astDump.h>
+
+namespace panda::es2panda::parser {
+
+Program::Program(ScriptExtension extension)
+    : allocator_(std::make_unique<ArenaAllocator>(SpaceType::SPACE_TYPE_COMPILER, nullptr, true)),
+      binder_(allocator_->New<binder::Binder>(this)),
+      sourceCode_(Allocator()),
+      sourceFile_(Allocator()),
+      extension_(extension)
+{
+}
+
+Program::Program(Program &&other)
+    : allocator_(std::move(other.allocator_)),
+      binder_(other.binder_),
+      ast_(other.ast_),
+      sourceCode_(other.sourceCode_),
+      sourceFile_(other.sourceFile_),
+      kind_(other.kind_),
+      extension_(other.extension_)
+{
+    other.binder_ = nullptr;
+    other.ast_ = nullptr;
+}
+
+Program &Program::operator=(Program &&other)
+{
+    allocator_ = std::move(other.allocator_);
+    binder_ = other.binder_;
+    ast_ = other.ast_;
+    sourceCode_ = other.sourceCode_;
+    sourceFile_ = other.sourceFile_;
+    kind_ = other.kind_;
+    extension_ = other.extension_;
+
+    other.ast_ = nullptr;
+
+    return *this;
+}
+
+void Program::SetKind(ScriptKind kind)
+{
+    kind_ = kind;
+    binder_->InitTopScope();
+}
+
+std::string Program::Dump() const
+{
+    ir::AstDumper dumper {ast_, SourceCode()};
+    return dumper.Str();
+}
+
+}  // namespace panda::es2panda::parser
diff --git a/es2panda/parser/program/program.h b/es2panda/parser/program/program.h
new file mode 100644
index 0000000000000000000000000000000000000000..75f399e87988d0fc6d7a4887ee99d3a88de43c7a
--- /dev/null
+++ b/es2panda/parser/program/program.h
@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_PARSER_INCLUDE_PROGRAM_H
+#define ES2PANDA_PARSER_INCLUDE_PROGRAM_H
+
+#include <macros.h>
+#include <mem/arena_allocator.h>
+#include <util/ustring.h>
+
+#include "es2panda.h"
+
+namespace panda::es2panda::ir {
+class BlockStatement;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::binder {
+class Binder;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::parser {
+
+enum class ScriptKind { SCRIPT, MODULE };
+
+class Program {
+public:
+    explicit Program(es2panda::ScriptExtension extension);
+    NO_COPY_SEMANTIC(Program);
+    Program(Program &&other);
+    Program &operator=(Program &&other);
+    ~Program() = default;
+
+    ArenaAllocator *Allocator() const
+    {
+        return allocator_.get();
+    }
+
+    const binder::Binder *Binder() const
+    {
+        return binder_;
+    }
+
+    binder::Binder *Binder()
+    {
+        return binder_;
+    }
+
+    ScriptExtension Extension() const
+    {
+        return extension_;
+    }
+
+    ScriptKind Kind() const
+    {
+        return kind_;
+    }
+
+    util::StringView SourceCode() const
+    {
+        return sourceCode_.View();
+    }
+
+    util::StringView SourceFile() const
+    {
+        return sourceFile_.View();
+    }
+
+    ir::BlockStatement *Ast()
+    {
+        return ast_;
+    }
+
+    const ir::BlockStatement *Ast() const
+    {
+        return ast_;
+    }
+
+    void SetAst(ir::BlockStatement *ast)
+    {
+        ast_ = ast;
+    }
+
+    void SetSource(const std::string &sourceCode, const std::string &sourceFile)
+    {
+        sourceCode_ = util::UString(sourceCode, Allocator());
+        sourceFile_ = util::UString(sourceFile, Allocator());
+    }
+
+    std::string Dump() const;
+    void SetKind(ScriptKind kind);
+
+private:
+    std::unique_ptr<ArenaAllocator> allocator_ {};
+    binder::Binder *binder_ {};
+    ir::BlockStatement *ast_ {};
+    util::UString sourceCode_ {};
+    util::UString sourceFile_ {};
+    ScriptKind kind_ {};
+    ScriptExtension extension_ {};
+};
+
+}  // namespace panda::es2panda::parser
+
+#endif
diff --git a/es2panda/parser/statementParser.cpp b/es2panda/parser/statementParser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a06a84efb4e124c1b1a3521b5c7cc7e675ef83a
--- /dev/null
+++ b/es2panda/parser/statementParser.cpp
@@ -0,0 +1,2422 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <util/helpers.h>
+#include <binder/tsBinding.h>
+#include <ir/astNode.h>
+#include <ir/base/catchClause.h>
+#include <ir/base/classDefinition.h>
+#include <ir/base/decorator.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/expression.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/binaryExpression.h>
+#include <ir/expressions/conditionalExpression.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/expressions/sequenceExpression.h>
+#include <ir/module/exportAllDeclaration.h>
+#include <ir/module/exportDefaultDeclaration.h>
+#include <ir/module/exportNamedDeclaration.h>
+#include <ir/module/exportSpecifier.h>
+#include <ir/module/importDeclaration.h>
+#include <ir/module/importDefaultSpecifier.h>
+#include <ir/module/importNamespaceSpecifier.h>
+#include <ir/module/importSpecifier.h>
+#include <ir/statements/blockStatement.h>
+#include <ir/statements/breakStatement.h>
+#include <ir/statements/classDeclaration.h>
+#include <ir/statements/continueStatement.h>
+#include <ir/statements/debuggerStatement.h>
+#include <ir/statements/doWhileStatement.h>
+#include <ir/statements/emptyStatement.h>
+#include <ir/statements/expressionStatement.h>
+#include <ir/statements/forInStatement.h>
+#include <ir/statements/forOfStatement.h>
+#include <ir/statements/forUpdateStatement.h>
+#include <ir/statements/functionDeclaration.h>
+#include <ir/statements/ifStatement.h>
+#include <ir/statements/labelledStatement.h>
+#include <ir/statements/returnStatement.h>
+#include <ir/statements/switchCaseStatement.h>
+#include <ir/statements/switchStatement.h>
+#include <ir/statements/throwStatement.h>
+#include <ir/statements/tryStatement.h>
+#include <ir/statements/variableDeclaration.h>
+#include <ir/statements/variableDeclarator.h>
+#include <ir/statements/whileStatement.h>
+#include <ir/ts/tsEnumDeclaration.h>
+#include <ir/ts/tsExternalModuleReference.h>
+#include <ir/ts/tsImportEqualsDeclaration.h>
+#include <ir/ts/tsInterfaceBody.h>
+#include <ir/ts/tsInterfaceDeclaration.h>
+#include <ir/ts/tsInterfaceHeritage.h>
+#include <ir/ts/tsModuleBlock.h>
+#include <ir/ts/tsModuleDeclaration.h>
+#include <ir/ts/tsTypeAliasDeclaration.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+#include <lexer/lexer.h>
+#include <lexer/token/letters.h>
+#include <lexer/token/sourceLocation.h>
+#include <util/ustring.h>
+
+#include <tuple>
+
+#include "parserImpl.h"
+
+namespace panda::es2panda::parser {
+
+void ParserImpl::CheckDeclare()
+{
+    ASSERT(lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_DECLARE);
+
+    if (context_.Status() & ParserStatus::IN_AMBIENT_CONTEXT) {
+        ThrowSyntaxError("A 'declare' modifier cannot be used in an already ambient context.");
+    }
+
+    lexer_->NextToken();  // eat 'declare'
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::KEYW_VAR:
+        case lexer::TokenType::KEYW_LET:
+        case lexer::TokenType::KEYW_CONST:
+        case lexer::TokenType::KEYW_FUNCTION:
+        case lexer::TokenType::KEYW_CLASS: {
+            break;
+        }
+        case lexer::TokenType::LITERAL_IDENT:
+            if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_TYPE ||
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_MODULE ||
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_GLOBAL ||
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_NAMESPACE ||
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ENUM ||
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ABSTRACT ||
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_INTERFACE) {
+                break;
+            }
+
+            [[fallthrough]];
+        default: {
+            ThrowSyntaxError("Unexpected token.");
+        }
+    }
+}
+
+ir::Statement *ParserImpl::ParseStatement(StatementParsingFlags flags)
+{
+    bool isDeclare = false;
+    auto decorators = ParseDecorators();
+
+    if (Extension() == ScriptExtension::TS) {
+        if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_DECLARE) {
+            CheckDeclare();
+            isDeclare = true;
+        }
+
+        if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ABSTRACT) {
+            lexer_->NextToken();  // eat abstract keyword
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::KEYW_CLASS) {
+                ThrowSyntaxError("abstract modifier can only appear on a class, method, or property declaration.");
+            }
+            return ParseClassStatement(flags, isDeclare, std::move(decorators), true);
+        }
+
+        if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_GLOBAL ||
+            lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_MODULE ||
+            lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_NAMESPACE) {
+            auto savedStatus = context_.Status();
+            if (isDeclare) {
+                context_.Status() |= ParserStatus::IN_AMBIENT_CONTEXT;
+            }
+            ir::TSModuleDeclaration *decl = ParseTsModuleDeclaration(isDeclare);
+            context_.Status() = savedStatus;
+            return decl;
+        }
+    }
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::PUNCTUATOR_LEFT_BRACE: {
+            return ParseBlockStatement();
+        }
+        case lexer::TokenType::PUNCTUATOR_SEMI_COLON: {
+            return ParseEmptyStatement();
+        }
+        case lexer::TokenType::KEYW_EXPORT: {
+            return ParseExportDeclaration(flags, std::move(decorators));
+        }
+        case lexer::TokenType::KEYW_IMPORT: {
+            return ParseImportDeclaration(flags);
+        }
+        case lexer::TokenType::KEYW_FUNCTION: {
+            return ParseFunctionStatement(flags, isDeclare);
+        }
+        case lexer::TokenType::KEYW_CLASS: {
+            return ParseClassStatement(flags, isDeclare, std::move(decorators));
+        }
+        case lexer::TokenType::KEYW_VAR: {
+            return ParseVarStatement(isDeclare);
+        }
+        case lexer::TokenType::KEYW_LET: {
+            return ParseLetStatement(flags, isDeclare);
+        }
+        case lexer::TokenType::KEYW_CONST: {
+            return ParseConstStatement(flags, isDeclare);
+        }
+        case lexer::TokenType::KEYW_IF: {
+            return ParseIfStatement();
+        }
+        case lexer::TokenType::KEYW_DO: {
+            return ParseDoWhileStatement();
+        }
+        case lexer::TokenType::KEYW_FOR: {
+            return ParseForStatement();
+        }
+        case lexer::TokenType::KEYW_TRY: {
+            return ParseTryStatement();
+        }
+        case lexer::TokenType::KEYW_WHILE: {
+            return ParseWhileStatement();
+        }
+        case lexer::TokenType::KEYW_BREAK: {
+            return ParseBreakStatement();
+        }
+        case lexer::TokenType::KEYW_CONTINUE: {
+            return ParseContinueStatement();
+        }
+        case lexer::TokenType::KEYW_THROW: {
+            return ParseThrowStatement();
+        }
+        case lexer::TokenType::KEYW_RETURN: {
+            return ParseReturnStatement();
+        }
+        case lexer::TokenType::KEYW_SWITCH: {
+            return ParseSwitchStatement();
+        }
+        case lexer::TokenType::KEYW_DEBUGGER: {
+            return ParseDebuggerStatement();
+        }
+        case lexer::TokenType::LITERAL_IDENT: {
+            return ParsePotentialExpressionStatement(flags, isDeclare);
+        }
+        default: {
+            break;
+        }
+    }
+
+    return ParseExpressionStatement(flags);
+}
+
+ir::TSModuleDeclaration *ParserImpl::ParseTsModuleDeclaration(bool isDeclare)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    context_.Status() |= ParserStatus::MODULE;
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_GLOBAL) {
+        return ParseTsAmbientExternalModuleDeclaration(startLoc, isDeclare);
+    }
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_NAMESPACE) {
+        lexer_->NextToken();
+    } else {
+        ASSERT(lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_MODULE);
+        lexer_->NextToken();
+        if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING) {
+            return ParseTsAmbientExternalModuleDeclaration(startLoc, isDeclare);
+        }
+    }
+
+    return ParseTsModuleOrNamespaceDelaration(startLoc, isDeclare);
+}
+
+ir::TSModuleDeclaration *ParserImpl::ParseTsAmbientExternalModuleDeclaration(const lexer::SourcePosition &startLoc,
+                                                                             bool isDeclare)
+{
+    bool isGlobal = false;
+    ir::Expression *name = nullptr;
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_GLOBAL) {
+        isGlobal = true;
+        name = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    } else {
+        ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING);
+
+        if (!isDeclare && !(context_.Status() & ParserStatus::IN_AMBIENT_CONTEXT)) {
+            ThrowSyntaxError("Only ambient modules can use quoted names");
+        }
+
+        name = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+    }
+
+    name->SetRange(lexer_->GetToken().Loc());
+
+    lexer_->NextToken();
+
+    auto localCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+
+    ir::Statement *body = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        body = ParseTsModuleBlock();
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        lexer_->NextToken();
+    } else {
+        ThrowSyntaxError("';' expected");
+    }
+
+    auto *moduleDecl = AllocNode<ir::TSModuleDeclaration>(localCtx.GetScope(), name, body, isDeclare, isGlobal);
+    moduleDecl->SetRange({startLoc, lexer_->GetToken().End()});
+    localCtx.GetScope()->BindNode(moduleDecl);
+
+    return moduleDecl;
+}
+
+ir::TSModuleDeclaration *ParserImpl::ParseTsModuleOrNamespaceDelaration(const lexer::SourcePosition &startLoc,
+                                                                        bool isDeclare)
+{
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Identifier expected");
+    }
+
+    auto *decl = Binder()->AddDecl<binder::VarDecl>(lexer_->GetToken().Start(), lexer_->GetToken().Ident());
+
+    auto *identNode = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    identNode->SetRange(lexer_->GetToken().Loc());
+
+    lexer_->NextToken();
+
+    ir::Statement *body = nullptr;
+
+    auto savedStatus = context_.Status();
+    if (isDeclare) {
+        context_.Status() |= ParserStatus::IN_AMBIENT_CONTEXT;
+    }
+
+    auto localCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+        lexer_->NextToken();
+        lexer::SourcePosition moduleStart = lexer_->GetToken().Start();
+        body = ParseTsModuleOrNamespaceDelaration(moduleStart, false);
+    } else {
+        body = ParseTsModuleBlock();
+    }
+
+    context_.Status() = savedStatus;
+
+    auto *moduleDecl = AllocNode<ir::TSModuleDeclaration>(localCtx.GetScope(), identNode, body, isDeclare, false);
+    moduleDecl->SetRange({startLoc, lexer_->GetToken().End()});
+    localCtx.GetScope()->BindNode(moduleDecl);
+    decl->BindNode(moduleDecl);
+
+    return moduleDecl;
+}
+
+ir::TSImportEqualsDeclaration *ParserImpl::ParseTsImportEqualsDeclaration(const lexer::SourcePosition &startLoc,
+                                                                          bool isExport)
+{
+    ASSERT(lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_IMPORT);
+    lexer_->NextToken();
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    auto *id = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    id->SetRange(lexer_->GetToken().Loc());
+    lexer_->NextToken();  // eat id name
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        ThrowSyntaxError("'=' expected");
+    }
+    lexer_->NextToken();  // eat substitution
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("identifier expected");
+    }
+
+    auto *importEqualsDecl = AllocNode<ir::TSImportEqualsDeclaration>(id, ParseModuleReference(), isExport);
+    importEqualsDecl->SetRange({startLoc, lexer_->GetToken().End()});
+
+    ConsumeSemicolon(importEqualsDecl);
+
+    return importEqualsDecl;
+}
+
+ir::TSModuleBlock *ParserImpl::ParseTsModuleBlock()
+{
+    auto localCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        ThrowSyntaxError("'{' expected.");
+    }
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+    auto statements = ParseStatementList();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ThrowSyntaxError("Expected a '}'");
+    }
+
+    auto *blockNode = AllocNode<ir::TSModuleBlock>(localCtx.GetScope(), std::move(statements));
+    blockNode->SetRange({startLoc, lexer_->GetToken().End()});
+    localCtx.GetScope()->BindNode(blockNode);
+
+    lexer_->NextToken();
+    return blockNode;
+}
+
+ir::Statement *ParserImpl::ParseVarStatement(bool isDeclare)
+{
+    auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::VAR, isDeclare);
+    ConsumeSemicolon(variableDecl);
+    return variableDecl;
+}
+
+ir::Statement *ParserImpl::ParseLetStatement(StatementParsingFlags flags, bool isDeclare)
+{
+    if (!(flags & StatementParsingFlags::ALLOW_LEXICAL)) {
+        ThrowSyntaxError("Lexical declaration is not allowed in single statement context");
+    }
+
+    auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::LET, isDeclare);
+    ConsumeSemicolon(variableDecl);
+    return variableDecl;
+}
+
+ir::Statement *ParserImpl::ParseConstStatement(StatementParsingFlags flags, bool isDeclare)
+{
+    if (!(flags & StatementParsingFlags::ALLOW_LEXICAL)) {
+        ThrowSyntaxError("Lexical declaration is not allowed in single statement context");
+    }
+
+    lexer::SourcePosition constVarStar = lexer_->GetToken().Start();
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ENUM) {
+        if (Extension() == ScriptExtension::TS) {
+            return ParseEnumDeclaration(true);
+        }
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    auto *variableDecl =
+        ParseVariableDeclaration(VariableParsingFlags::CONST | VariableParsingFlags::NO_SKIP_VAR_KIND, isDeclare);
+    variableDecl->SetStart(constVarStar);
+    ConsumeSemicolon(variableDecl);
+
+    return variableDecl;
+}
+
+ir::EmptyStatement *ParserImpl::ParseEmptyStatement()
+{
+    auto *empty = AllocNode<ir::EmptyStatement>();
+    empty->SetRange(lexer_->GetToken().Loc());
+    lexer_->NextToken();
+    return empty;
+}
+
+ir::DebuggerStatement *ParserImpl::ParseDebuggerStatement()
+{
+    auto *debuggerNode = AllocNode<ir::DebuggerStatement>();
+    debuggerNode->SetRange(lexer_->GetToken().Loc());
+    lexer_->NextToken();
+    ConsumeSemicolon(debuggerNode);
+    return debuggerNode;
+}
+
+ir::Statement *ParserImpl::ParseFunctionStatement(StatementParsingFlags flags, bool isDeclare)
+{
+    CheckFunctionDeclaration(flags);
+
+    if (!(flags & StatementParsingFlags::STMT_LEXICAL_SCOPE_NEEDED)) {
+        return ParseFunctionDeclaration(false, ParserStatus::NO_OPTS, isDeclare);
+    }
+
+    auto localCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+    ArenaVector<ir::Statement *> stmts(Allocator()->Adapter());
+    auto *funcDecl = ParseFunctionDeclaration(false, ParserStatus::NO_OPTS, isDeclare);
+    stmts.push_back(funcDecl);
+
+    auto *localBlockStmt = AllocNode<ir::BlockStatement>(localCtx.GetScope(), std::move(stmts));
+    localBlockStmt->SetRange(funcDecl->Range());
+    localCtx.GetScope()->BindNode(localBlockStmt);
+
+    return funcDecl;
+}
+
+ir::Statement *ParserImpl::ParsePotentialExpressionStatement(StatementParsingFlags flags, bool isDeclare)
+{
+    if (lexer_->Lookahead() == LEX_CHAR_COLON) {
+        const auto pos = lexer_->Save();
+        lexer_->NextToken();
+        return ParseLabelledStatement(pos);
+    }
+
+    if (Extension() == ScriptExtension::TS) {
+        switch (lexer_->GetToken().KeywordType()) {
+            case lexer::TokenType::KEYW_ENUM: {
+                return ParseEnumDeclaration();
+            }
+            case lexer::TokenType::KEYW_TYPE: {
+                return ParseTsTypeAliasDeclaration(isDeclare);
+            }
+            case lexer::TokenType::KEYW_INTERFACE: {
+                return ParseTsInterfaceDeclaration();
+            }
+            default:
+                break;
+        }
+    }
+
+    return ParseExpressionStatement(flags);
+}
+
+ir::ClassDeclaration *ParserImpl::ParseClassStatement(StatementParsingFlags flags, bool isDeclare,
+                                                      ArenaVector<ir::Decorator *> &&decorators, bool isAbstract)
+{
+    if (!(flags & StatementParsingFlags::ALLOW_LEXICAL)) {
+        ThrowSyntaxError("Lexical declaration is not allowed in single statement context");
+    }
+
+    return ParseClassDeclaration(true, std::move(decorators), isDeclare, isAbstract);
+}
+
+ir::ClassDeclaration *ParserImpl::ParseClassDeclaration(bool idRequired, ArenaVector<ir::Decorator *> &&decorators,
+                                                        bool isDeclare, bool isAbstract)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    ir::ClassDefinition *classDefinition = ParseClassDefinition(true, idRequired, isDeclare, isAbstract);
+
+    auto *decl =
+        Binder()->AddDecl<binder::LetDecl>(classDefinition->Ident()->Start(), classDefinition->Ident()->Name());
+    decl->BindNode(classDefinition);
+
+    lexer::SourcePosition endLoc = classDefinition->End();
+    auto *classDecl = AllocNode<ir::ClassDeclaration>(classDefinition, std::move(decorators));
+    classDecl->SetRange({startLoc, endLoc});
+    return classDecl;
+}
+
+ir::TSTypeAliasDeclaration *ParserImpl::ParseTsTypeAliasDeclaration(bool isDeclare)
+{
+    ASSERT(lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_TYPE);
+    lexer::SourcePosition typeStart = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat type keyword
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Identifier expected");
+    }
+
+    if (lexer_->GetToken().IsReservedTypeName()) {
+        std::string errMsg("Type alias name cannot be '");
+        errMsg.append(TokenToString(lexer_->GetToken().KeywordType()));
+        errMsg.append("'");
+        ThrowSyntaxError(errMsg.c_str());
+    }
+
+    const util::StringView &ident = lexer_->GetToken().Ident();
+    binder::TSBinding tsBinding(Allocator(), ident);
+    auto *decl = Binder()->AddTsDecl<binder::TypeAliasDecl>(lexer_->GetToken().Start(), tsBinding.View());
+
+    auto *id = AllocNode<ir::Identifier>(ident, Allocator());
+    id->SetRange(lexer_->GetToken().Loc());
+    lexer_->NextToken();
+
+    ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        typeParamDecl = ParseTsTypeParameterDeclaration();
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        ThrowSyntaxError("'=' expected");
+    }
+
+    lexer_->NextToken();  // eat '='
+
+    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+    ir::Expression *typeAnnotation = ParseTsTypeAnnotation(&options);
+
+    auto *typeAliasDecl = AllocNode<ir::TSTypeAliasDeclaration>(id, typeParamDecl, typeAnnotation, isDeclare);
+    typeAliasDecl->SetRange({typeStart, lexer_->GetToken().End()});
+    decl->BindNode(typeAliasDecl);
+
+    return typeAliasDecl;
+}
+
+ir::TSInterfaceDeclaration *ParserImpl::ParseTsInterfaceDeclaration()
+{
+    ASSERT(lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_INTERFACE);
+    context_.Status() |= ParserStatus::ALLOW_THIS_TYPE;
+    lexer::SourcePosition interfaceStart = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat interface keyword
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Identifier expected");
+    }
+
+    if (lexer_->GetToken().IsReservedTypeName()) {
+        std::string errMsg("Interface name cannot be '");
+        errMsg.append(TokenToString(lexer_->GetToken().KeywordType()));
+        errMsg.append("'");
+        ThrowSyntaxError(errMsg.c_str());
+    }
+
+    const util::StringView &ident = lexer_->GetToken().Ident();
+    binder::TSBinding tsBinding(Allocator(), ident);
+
+    const auto &bindings = Binder()->GetScope()->Bindings();
+    auto res = bindings.find(tsBinding.View());
+    binder::InterfaceDecl *decl {};
+
+    if (res == bindings.end()) {
+        decl = Binder()->AddTsDecl<binder::InterfaceDecl>(lexer_->GetToken().Start(), Allocator(), tsBinding.View());
+    } else if (!res->second->Declaration()->IsInterfaceDecl()) {
+        Binder()->ThrowRedeclaration(lexer_->GetToken().Start(), ident);
+    } else {
+        decl = res->second->Declaration()->AsInterfaceDecl();
+    }
+
+    auto *id = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+    id->SetRange(lexer_->GetToken().Loc());
+    lexer_->NextToken();
+
+    binder::LexicalScope<binder::LocalScope> localScope(Binder());
+
+    ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+        typeParamDecl = ParseTsTypeParameterDeclaration();
+    }
+
+    ArenaVector<ir::TSInterfaceHeritage *> extends(Allocator()->Adapter());
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_EXTENDS) {
+        lexer_->NextToken();  // eat extends keyword
+        while (true) {
+            if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+                ThrowSyntaxError("Identifier expected");
+            }
+
+            const lexer::SourcePosition &heritageStart = lexer_->GetToken().Start();
+            lexer::SourcePosition heritageEnd = lexer_->GetToken().End();
+            ir::Expression *expr = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+            expr->SetRange(lexer_->GetToken().Loc());
+
+            if (lexer_->Lookahead() == LEX_CHAR_LESS_THAN) {
+                lexer_->ForwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
+            } else {
+                lexer_->NextToken();
+            }
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+                expr = ParseTsQualifiedReference(expr);
+            }
+
+            ir::TSTypeParameterInstantiation *typeParamInst = nullptr;
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
+                typeParamInst = ParseTsTypeParameterInstantiation();
+                heritageEnd = typeParamInst->End();
+            }
+
+            auto *heritage = AllocNode<ir::TSInterfaceHeritage>(expr, typeParamInst);
+            heritage->SetRange({heritageStart, heritageEnd});
+            extends.push_back(heritage);
+
+            if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+                break;
+            }
+
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA) {
+                ThrowSyntaxError("',' expected");
+            }
+
+            lexer_->NextToken();
+        }
+    }
+
+    lexer::SourcePosition bodyStart = lexer_->GetToken().Start();
+    auto members = ParseTsTypeLiteralOrInterface();
+
+    auto *body = AllocNode<ir::TSInterfaceBody>(std::move(members));
+    body->SetRange({bodyStart, lexer_->GetToken().End()});
+
+    auto *interfaceDecl =
+        AllocNode<ir::TSInterfaceDeclaration>(localScope.GetScope(), id, typeParamDecl, body, std::move(extends));
+    interfaceDecl->SetRange({interfaceStart, lexer_->GetToken().End()});
+
+    ASSERT(decl);
+
+    if (res == bindings.end()) {
+        decl->BindNode(interfaceDecl);
+    } else {
+        decl->AsInterfaceDecl()->Add(interfaceDecl);
+    }
+
+    lexer_->NextToken();
+    context_.Status() &= ~ParserStatus::ALLOW_THIS_TYPE;
+
+    return interfaceDecl;
+}
+
+void ParserImpl::CheckFunctionDeclaration(StatementParsingFlags flags)
+{
+    if (flags & StatementParsingFlags::LABELLED) {
+        ThrowSyntaxError(
+            "In strict mode code, functions can only be "
+            "declared at top level, inside a block, "
+            "or "
+            "as the body of an if statement");
+    }
+
+    if (!(flags & StatementParsingFlags::ALLOW_LEXICAL)) {
+        if (!(flags & (StatementParsingFlags::IF_ELSE | StatementParsingFlags::LABELLED))) {
+            ThrowSyntaxError("Lexical declaration is not allowed in single statement context");
+        }
+
+        if (lexer_->Lookahead() == LEX_CHAR_ASTERISK) {
+            ThrowSyntaxError("Generators can only be declared at the top level or inside a block");
+        }
+    }
+}
+
+void ParserImpl::ConsumeSemicolon(ir::Statement *statement)
+{
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        statement->SetEnd(lexer_->GetToken().End());
+        lexer_->NextToken();
+        return;
+    }
+
+    if (!lexer_->GetToken().NewLine()) {
+        if (lexer_->GetToken().Type() != lexer::TokenType::EOS &&
+            lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+            ThrowSyntaxError("Unexpected token");
+        }
+    }
+}
+
+ArenaVector<ir::Statement *> ParserImpl::ParseStatementList(StatementParsingFlags flags)
+{
+    ArenaVector<ir::Statement *> statements(Allocator()->Adapter());
+    ParseDirectivePrologue(&statements);
+
+    auto endType =
+        (flags & StatementParsingFlags::GLOBAL) ? lexer::TokenType::EOS : lexer::TokenType::PUNCTUATOR_RIGHT_BRACE;
+
+    while (lexer_->GetToken().Type() != endType) {
+        statements.push_back(ParseStatement(flags));
+    }
+
+    return statements;
+}
+
+bool ParserImpl::ParseDirective(ArenaVector<ir::Statement *> *statements)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING);
+
+    const util::StringView &str = lexer_->GetToken().String();
+
+    const auto status = static_cast<ParserStatus>(
+        context_.Status() & (ParserStatus::CONSTRUCTOR_FUNCTION | ParserStatus::HAS_COMPLEX_PARAM));
+    if (status == ParserStatus::HAS_COMPLEX_PARAM && str.Is("use strict")) {
+        ThrowSyntaxError(
+            "Illegal 'use strict' directive in function with "
+            "non-simple parameter list");
+    }
+
+    ir::Expression *exprNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+    bool isDirective = exprNode->IsStringLiteral();
+
+    auto *exprStatement = AllocNode<ir::ExpressionStatement>(exprNode);
+    exprStatement->SetRange(exprNode->Range());
+
+    ConsumeSemicolon(exprStatement);
+    statements->push_back(exprStatement);
+
+    return isDirective;
+}
+
+void ParserImpl::ParseDirectivePrologue(ArenaVector<ir::Statement *> *statements)
+{
+    while (true) {
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_STRING || !ParseDirective(statements)) {
+            break;
+        }
+    }
+}
+
+ir::BlockStatement *ParserImpl::ParseBlockStatement(binder::Scope *scope)
+{
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE);
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+    auto statements = ParseStatementList();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ThrowSyntaxError("Expected a '}'");
+    }
+
+    auto *blockNode = AllocNode<ir::BlockStatement>(scope, std::move(statements));
+    blockNode->SetRange({startLoc, lexer_->GetToken().End()});
+    scope->BindNode(blockNode);
+
+    lexer_->NextToken();
+    return blockNode;
+}
+
+ir::BlockStatement *ParserImpl::ParseBlockStatement()
+{
+    auto localCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+    return ParseBlockStatement(localCtx.GetScope());
+}
+
+ir::BreakStatement *ParserImpl::ParseBreakStatement()
+{
+    bool allowBreak = (context_.Status() & (ParserStatus::IN_ITERATION | ParserStatus::IN_SWITCH));
+    if (Extension() == ScriptExtension::TS && (context_.Status() & ParserStatus::FUNCTION) && !allowBreak) {
+        ThrowSyntaxError("Jump target cannot cross function boundary");
+    }
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON ||
+        lexer_->GetToken().Type() == lexer::TokenType::EOS || lexer_->GetToken().NewLine()) {
+        if (!allowBreak) {
+            if (Extension() == ScriptExtension::JS) {
+                ThrowSyntaxError("Illegal break statement");
+            }
+            if (Extension() == ScriptExtension::TS) {
+                ThrowSyntaxError(
+                    "A 'break' statement can only be used within an "
+                    "enclosing iteration or switch statement");
+            }
+        }
+
+        auto *breakStatement = AllocNode<ir::BreakStatement>();
+        breakStatement->SetRange({startLoc, lexer_->GetToken().End()});
+        lexer_->NextToken();
+        return breakStatement;
+    }
+
+    if (lexer_->GetToken().NewLine() || lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        if (!allowBreak) {
+            if (Extension() == ScriptExtension::JS) {
+                ThrowSyntaxError("Illegal break statement");
+            }
+            if (Extension() == ScriptExtension::TS) {
+                ThrowSyntaxError(
+                    "A 'break' statement can only be used within an "
+                    "enclosing iteration or switch statement");
+            }
+        }
+
+        auto *breakStatement = AllocNode<ir::BreakStatement>();
+        breakStatement->SetRange({startLoc, endLoc});
+        return breakStatement;
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Unexpected token.");
+    }
+
+    const auto &label = lexer_->GetToken().Ident();
+
+    if (!context_.FindLabel(label)) {
+        ThrowSyntaxError("Undefined label");
+    }
+
+    auto *identNode = AllocNode<ir::Identifier>(label, Allocator());
+    identNode->SetRange(lexer_->GetToken().Loc());
+
+    auto *breakStatement = AllocNode<ir::BreakStatement>(identNode);
+    breakStatement->SetRange({startLoc, lexer_->GetToken().End()});
+
+    lexer_->NextToken();
+    ConsumeSemicolon(breakStatement);
+
+    return breakStatement;
+}
+
+ir::ContinueStatement *ParserImpl::ParseContinueStatement()
+{
+    if (Extension() == ScriptExtension::TS &&
+        (static_cast<ParserStatus>(context_.Status() & (ParserStatus::FUNCTION | ParserStatus::IN_ITERATION |
+                                                        ParserStatus::IN_SWITCH)) == ParserStatus::FUNCTION)) {
+        ThrowSyntaxError("Jump target cannot cross function boundary");
+    }
+
+    if (!(context_.Status() & ParserStatus::IN_ITERATION)) {
+        if (Extension() == ScriptExtension::JS) {
+            ThrowSyntaxError("Illegal continue statement");
+        }
+        if (Extension() == ScriptExtension::TS) {
+            ThrowSyntaxError(
+                "A 'continue' statement can only be used within an "
+                "enclosing iteration statement");
+        }
+    }
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        auto *continueStatement = AllocNode<ir::ContinueStatement>();
+        continueStatement->SetRange({startLoc, lexer_->GetToken().End()});
+        lexer_->NextToken();
+        return continueStatement;
+    }
+
+    if (lexer_->GetToken().NewLine() || lexer_->GetToken().Type() == lexer::TokenType::EOS ||
+        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        auto *continueStatement = AllocNode<ir::ContinueStatement>();
+        continueStatement->SetRange({startLoc, endLoc});
+        return continueStatement;
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Unexpected token.");
+    }
+
+    const auto &label = lexer_->GetToken().Ident();
+    const ParserContext *labelCtx = context_.FindLabel(label);
+
+    if (!labelCtx || !(labelCtx->Status() & ParserStatus::IN_ITERATION)) {
+        ThrowSyntaxError("Undefined label");
+    }
+
+    auto *identNode = AllocNode<ir::Identifier>(label, Allocator());
+    identNode->SetRange(lexer_->GetToken().Loc());
+
+    auto *continueStatement = AllocNode<ir::ContinueStatement>(identNode);
+    continueStatement->SetRange({startLoc, lexer_->GetToken().End()});
+
+    lexer_->NextToken();
+    ConsumeSemicolon(continueStatement);
+
+    return continueStatement;
+}
+
+ir::DoWhileStatement *ParserImpl::ParseDoWhileStatement()
+{
+    IterationContext<binder::LoopScope> iterCtx(&context_, Binder());
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+    ir::Statement *body = ParseStatement();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::KEYW_WHILE) {
+        ThrowSyntaxError("Missing 'while' keyword in a 'DoWhileStatement'");
+    }
+
+    lexer_->NextToken();
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        ThrowSyntaxError("Missing left parenthesis in a 'DoWhileStatement'");
+    }
+
+    lexer_->NextToken();
+
+    ir::Expression *test = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Missing right parenthesis in a 'DoWhileStatement'");
+    }
+
+    auto *doWhileStatement = AllocNode<ir::DoWhileStatement>(iterCtx.LexicalScope().GetScope(), body, test);
+    doWhileStatement->SetRange({startLoc, lexer_->GetToken().End()});
+    iterCtx.LexicalScope().GetScope()->BindNode(doWhileStatement);
+
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        doWhileStatement->SetEnd(lexer_->GetToken().End());
+        lexer_->NextToken();
+    }
+
+    return doWhileStatement;
+}
+
+ir::FunctionDeclaration *ParserImpl::ParseFunctionDeclaration(bool canBeAnonymous, ParserStatus newStatus,
+                                                              bool isDeclare)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_FUNCTION);
+    ParserStatus savedStatus = context_.Status();
+
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MULTIPLY) {
+        newStatus |= ParserStatus::GENERATOR_FUNCTION;
+        lexer_->NextToken();
+    }
+
+    context_.Status() = savedStatus;
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT &&
+        lexer_->GetToken().Type() != lexer::TokenType::KEYW_AWAIT) {
+        if (canBeAnonymous) {
+            ir::ScriptFunction *func = ParseFunction(newStatus, isDeclare);
+            func->SetStart(startLoc);
+
+            auto *funcDecl = AllocNode<ir::FunctionDeclaration>(func);
+            funcDecl->SetRange(func->Range());
+            return funcDecl;
+        }
+
+        ThrowSyntaxError("Unexpected token, expected identifier after 'function' keyword");
+    }
+
+    if (lexer_->GetToken().KeywordType() >= lexer::TokenType::KEYW_ARGUMENTS) {
+        ThrowSyntaxError("Unexpected reserved word in strict mode.");
+    }
+
+    util::StringView ident = lexer_->GetToken().Ident();
+
+    auto *identNode = AllocNode<ir::Identifier>(ident, Allocator());
+    identNode->SetRange(lexer_->GetToken().Loc());
+    lexer_->NextToken();
+
+    newStatus |= ParserStatus::FUNCTION_DECLARATION;
+    ir::ScriptFunction *func = ParseFunction(newStatus, isDeclare);
+
+    func->SetIdent(identNode);
+    func->SetStart(startLoc);
+    auto *funcDecl = AllocNode<ir::FunctionDeclaration>(func);
+    funcDecl->SetRange(func->Range());
+
+    if (!func->IsOverload()) {
+        Binder()->AddDecl<binder::FunctionDecl>(identNode->Start(), Allocator(), ident, func);
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        lexer_->NextToken();
+    }
+
+    return funcDecl;
+}
+
+ir::Statement *ParserImpl::ParseExpressionStatement(StatementParsingFlags flags)
+{
+    const auto startPos = lexer_->Save();
+    ParserStatus savedStatus = context_.Status();
+
+    if (lexer_->GetToken().IsAsyncModifier()) {
+        context_.Status() |= ParserStatus::ASYNC_FUNCTION;
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_FUNCTION && !lexer_->GetToken().NewLine()) {
+            if (!(flags & StatementParsingFlags::ALLOW_LEXICAL)) {
+                ThrowSyntaxError("Lexical declaration is not allowed in single statement context");
+            }
+
+            ir::FunctionDeclaration *functionDecl = ParseFunctionDeclaration(false, ParserStatus::ASYNC_FUNCTION);
+            functionDecl->SetStart(startPos.token.Start());
+
+            return functionDecl;
+        }
+
+        lexer_->Rewind(startPos);
+    }
+
+    ir::Expression *exprNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+    context_.Status() = savedStatus;
+    lexer::SourcePosition endPos = exprNode->End();
+
+    auto *exprStatementNode = AllocNode<ir::ExpressionStatement>(exprNode);
+    exprStatementNode->SetRange({startPos.token.Start(), endPos});
+    ConsumeSemicolon(exprStatementNode);
+
+    return exprStatementNode;
+}
+
+std::tuple<ForStatementKind, ir::Expression *, ir::Expression *> ParserImpl::ParseForInOf(
+    ir::AstNode *initNode, ExpressionParseFlags exprFlags, bool isAwait)
+{
+    ForStatementKind forKind = ForStatementKind::UPDATE;
+    ir::Expression *updateNode = nullptr;
+    ir::Expression *rightNode = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_IN ||
+        lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_OF) {
+        const ir::VariableDeclarator *varDecl = initNode->AsVariableDeclaration()->Declarators().front();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_IN) {
+            if (varDecl->Init()) {
+                ThrowSyntaxError("for-in loop variable declaration may not have an initializer");
+            }
+            forKind = ForStatementKind::IN;
+            exprFlags = ExpressionParseFlags::ACCEPT_COMMA;
+        } else {
+            if (varDecl->Init()) {
+                ThrowSyntaxError("for-of loop variable declaration may not have an initializer");
+            }
+
+            forKind = ForStatementKind::OF;
+        }
+
+        lexer_->NextToken();
+        rightNode = ParseExpression(exprFlags);
+    } else {
+        if (isAwait) {
+            ThrowSyntaxError("Unexpected token");
+        }
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+            ThrowSyntaxError("Invalid left-hand side in 'For[In/Of]Statement'");
+        } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+            lexer_->NextToken();
+        } else {
+            rightNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+            if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+                ThrowSyntaxError("Unexpected token, expected ';' in 'ForStatement'.");
+            }
+            lexer_->NextToken();
+        }
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+            updateNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+        }
+    }
+
+    return {forKind, rightNode, updateNode};
+}
+
+std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParserImpl::ParseForInOf(
+    ir::Expression *leftNode, ExpressionParseFlags exprFlags, bool isAwait)
+{
+    ForStatementKind forKind = ForStatementKind::UPDATE;
+    ir::AstNode *initNode = nullptr;
+    ir::Expression *updateNode = nullptr;
+    ir::Expression *rightNode = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_IN ||
+        (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_OF)) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_IN) {
+            forKind = ForStatementKind::IN;
+            exprFlags = ExpressionParseFlags::ACCEPT_COMMA;
+        } else {
+            forKind = ForStatementKind::OF;
+        }
+
+        bool isValid = true;
+        switch (leftNode->Type()) {
+            case ir::AstNodeType::IDENTIFIER:
+            case ir::AstNodeType::MEMBER_EXPRESSION: {
+                break;
+            }
+            case ir::AstNodeType::ARRAY_EXPRESSION: {
+                isValid = leftNode->AsArrayExpression()->ConvertibleToArrayPattern();
+                break;
+            }
+            case ir::AstNodeType::OBJECT_EXPRESSION: {
+                isValid = leftNode->AsObjectExpression()->ConvertibleToObjectPattern();
+                break;
+            }
+            default: {
+                isValid = false;
+            }
+        }
+
+        if (!isValid) {
+            ValidateLvalueAssignmentTarget(leftNode);
+        }
+
+        initNode = leftNode;
+        lexer_->NextToken();
+        rightNode = ParseExpression(exprFlags);
+
+        return {forKind, initNode, rightNode, updateNode};
+    }
+
+    if (isAwait) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    ir::Expression *expr = ParseAssignmentExpression(leftNode);
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+        initNode = ParseSequenceExpression(expr);
+    } else {
+        initNode = expr;
+    }
+
+    if (initNode->IsConditionalExpression()) {
+        ir::ConditionalExpression *condExpr = initNode->AsConditionalExpression();
+        if (condExpr->Alternate()->IsBinaryExpression()) {
+            const auto *binaryExpr = condExpr->Alternate()->AsBinaryExpression();
+            if (binaryExpr->OperatorType() == lexer::TokenType::KEYW_IN) {
+                ThrowSyntaxError("Invalid left-hand side in for-in statement");
+            }
+        }
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Invalid left-hand side in 'For[In/Of]Statement'");
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        ThrowSyntaxError("Unexpected token, expected ';' in 'ForStatement'.");
+    }
+
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        lexer_->NextToken();
+    } else {
+        rightNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+            ThrowSyntaxError("Unexpected token, expected ';' in 'ForStatement'.");
+        }
+        lexer_->NextToken();
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        updateNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+    }
+
+    return {forKind, initNode, rightNode, updateNode};
+}
+
+std::tuple<ir::Expression *, ir::Expression *> ParserImpl::ParseForUpdate(bool isAwait)
+{
+    if (isAwait) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    ir::Expression *updateNode = nullptr;
+    ir::Expression *rightNode = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+        lexer_->NextToken();
+    } else {
+        rightNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+            ThrowSyntaxError("Unexpected token, expected ';' in 'ForStatement'.");
+        }
+        lexer_->NextToken();
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        updateNode = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+    }
+
+    return {rightNode, updateNode};
+}
+
+ir::Statement *ParserImpl::ParseForStatement()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    ForStatementKind forKind = ForStatementKind::UPDATE;
+    ir::AstNode *initNode = nullptr;
+    ir::Expression *updateNode = nullptr;
+    ir::Expression *leftNode = nullptr;
+    ir::Expression *rightNode = nullptr;
+    bool canBeForInOf = true;
+    bool isAwait = false;
+    lexer_->NextToken();
+    VariableParsingFlags varFlags = VariableParsingFlags::STOP_AT_IN;
+    ExpressionParseFlags exprFlags = ExpressionParseFlags::NO_OPTS;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_AWAIT) {
+        isAwait = true;
+        varFlags |= VariableParsingFlags::DISALLOW_INIT;
+        lexer_->NextToken();
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        ThrowSyntaxError("Missing left parenthesis in a 'ForStatement'");
+    }
+    lexer_->NextToken();
+
+    auto declCtx = binder::LexicalScope<binder::LoopDeclarationScope>(Binder());
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::KEYW_VAR: {
+            initNode = ParseVariableDeclaration(varFlags | VariableParsingFlags::VAR);
+            break;
+        }
+        case lexer::TokenType::KEYW_LET: {
+            initNode = ParseVariableDeclaration(varFlags | VariableParsingFlags::LET);
+            break;
+        }
+        case lexer::TokenType::KEYW_CONST: {
+            initNode = ParseVariableDeclaration(varFlags | VariableParsingFlags::CONST |
+                                                VariableParsingFlags::ACCEPT_CONST_NO_INIT);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_SEMI_COLON: {
+            if (isAwait) {
+                ThrowSyntaxError("Unexpected token");
+            }
+
+            canBeForInOf = false;
+            lexer_->NextToken();
+            break;
+        }
+        default: {
+            leftNode = ParseUnaryOrPrefixUpdateExpression(ExpressionParseFlags::POTENTIALLY_IN_PATTERN);
+
+            break;
+        }
+    }
+
+    IterationContext<binder::LoopScope> iterCtx(&context_, Binder());
+    iterCtx.LexicalScope().GetScope()->BindDecls(declCtx.GetScope());
+
+    if (initNode != nullptr) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) {
+            lexer_->NextToken();
+            canBeForInOf = false;
+        } else {
+            canBeForInOf = initNode->AsVariableDeclaration()->Declarators().size() == 1;
+        }
+    }
+
+    // VariableDeclaration->DeclarationSize > 1 or seen semi_colon
+    if (!canBeForInOf) {
+        std::tie(rightNode, updateNode) = ParseForUpdate(isAwait);
+    } else if (leftNode) {
+        // initNode was parsed as LHS
+        std::tie(forKind, initNode, rightNode, updateNode) = ParseForInOf(leftNode, exprFlags, isAwait);
+    } else if (initNode) {
+        // initNode was parsed as VariableDeclaration and declaration size = 1
+        std::tie(forKind, rightNode, updateNode) = ParseForInOf(initNode, exprFlags, isAwait);
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token, expected ')' in 'ForStatement'.");
+    }
+    lexer_->NextToken();
+
+    ir::Statement *bodyNode = ParseStatement();
+    lexer::SourcePosition endLoc = bodyNode->End();
+
+    ir::Statement *forStatement = nullptr;
+    auto *loopScope = iterCtx.LexicalScope().GetScope();
+
+    if (forKind == ForStatementKind::UPDATE) {
+        forStatement = AllocNode<ir::ForUpdateStatement>(loopScope, initNode, rightNode, updateNode, bodyNode);
+    } else if (forKind == ForStatementKind::IN) {
+        forStatement = AllocNode<ir::ForInStatement>(loopScope, initNode, rightNode, bodyNode);
+    } else {
+        forStatement = AllocNode<ir::ForOfStatement>(loopScope, initNode, rightNode, bodyNode, isAwait);
+    }
+
+    forStatement->SetRange({startLoc, endLoc});
+    loopScope->BindNode(forStatement);
+    loopScope->DeclScope()->BindNode(forStatement);
+
+    return forStatement;
+}
+
+ir::IfStatement *ParserImpl::ParseIfStatement()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        ThrowSyntaxError("Missing left parenthesis in an 'IfStatement'");
+    }
+
+    lexer_->NextToken();
+    ir::Expression *test = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Missing right parenthesis in an 'IfStatement'");
+    }
+
+    lexer_->NextToken();
+    ir::Statement *consequent = ParseStatement(StatementParsingFlags::IF_ELSE | StatementParsingFlags::ALLOW_LEXICAL);
+
+    if (Extension() == ScriptExtension::TS && consequent->IsEmptyStatement()) {
+        ThrowSyntaxError("The body of an if statement cannot be the empty statement");
+    }
+
+    endLoc = consequent->End();
+    ir::Statement *alternate = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_ELSE) {
+        lexer_->NextToken();  // eat ELSE keyword
+        alternate = ParseStatement(StatementParsingFlags::IF_ELSE | StatementParsingFlags::ALLOW_LEXICAL);
+        endLoc = alternate->End();
+    }
+
+    auto *ifStatement = AllocNode<ir::IfStatement>(test, consequent, alternate);
+    ifStatement->SetRange({startLoc, endLoc});
+    return ifStatement;
+}
+
+ir::LabelledStatement *ParserImpl::ParseLabelledStatement(const lexer::LexerPosition &pos)
+{
+    const util::StringView &actualLabel = pos.token.Ident();
+
+    // TODO(frobert) : check correctness
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AWAIT && context_.IsModule()) {
+        ThrowSyntaxError("'await' is a reserved identifier in module code", pos.token.Start());
+    }
+
+    if (context_.FindLabel(actualLabel)) {
+        ThrowSyntaxError("Label already declared", pos.token.Start());
+    }
+
+    SavedParserContext newCtx(this, ParserStatus::IN_LABELED, actualLabel);
+
+    auto *identNode = AllocNode<ir::Identifier>(actualLabel, Allocator());
+    identNode->SetRange(pos.token.Loc());
+
+    lexer_->NextToken();
+
+    ir::Statement *body = ParseStatement(StatementParsingFlags::LABELLED);
+
+    auto *labeledStatement = AllocNode<ir::LabelledStatement>(identNode, body);
+    labeledStatement->SetRange({pos.token.Start(), body->End()});
+
+    return labeledStatement;
+}
+
+ir::ReturnStatement *ParserImpl::ParseReturnStatement()
+{
+    if (!(context_.Status() & ParserStatus::FUNCTION)) {
+        ThrowSyntaxError("return keyword should be used in function body");
+    }
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+    lexer_->NextToken();
+
+    bool hasArgument = (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON &&
+                        lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE &&
+                        lexer_->GetToken().Type() != lexer::TokenType::EOS && !lexer_->GetToken().NewLine());
+
+    ir::ReturnStatement *returnStatement = nullptr;
+
+    if (hasArgument) {
+        ir::Expression *expression = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+        endLoc = expression->End();
+        returnStatement = AllocNode<ir::ReturnStatement>(expression);
+    } else {
+        returnStatement = AllocNode<ir::ReturnStatement>();
+    }
+
+    returnStatement->SetRange({startLoc, endLoc});
+    ConsumeSemicolon(returnStatement);
+
+    return returnStatement;
+}
+
+ir::SwitchCaseStatement *ParserImpl::ParseSwitchCaseStatement(bool *seenDefault)
+{
+    lexer::SourcePosition caseStartLoc = lexer_->GetToken().Start();
+    ir::Expression *testExpr = nullptr;
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::KEYW_CASE: {
+            lexer_->NextToken();
+            testExpr = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+            break;
+        }
+        case lexer::TokenType::KEYW_DEFAULT: {
+            if (*seenDefault) {
+                if (Extension() == ScriptExtension::TS) {
+                    ThrowSyntaxError(
+                        "A 'default' clause cannot appear more than once in a "
+                        "'switch' statement");
+                } else {
+                    ThrowSyntaxError("Multiple default clauses.");
+                }
+            }
+            *seenDefault = true;
+            lexer_->NextToken();
+            break;
+        }
+        default: {
+            ThrowSyntaxError("Unexpected token, expected 'case' or 'default'.");
+        }
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COLON) {
+        ThrowSyntaxError("Unexpected token, expected ':'");
+    }
+
+    ArenaVector<ir::Statement *> consequents(Allocator()->Adapter());
+    lexer::SourcePosition caseEndLoc = lexer_->GetToken().End();
+
+    lexer_->NextToken();
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::KEYW_CASE &&
+           lexer_->GetToken().Type() != lexer::TokenType::KEYW_DEFAULT &&
+           lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        ir::Statement *consequent = ParseStatement(StatementParsingFlags::ALLOW_LEXICAL);
+        caseEndLoc = consequent->End();
+        consequents.push_back(consequent);
+    }
+
+    auto *caseNode = AllocNode<ir::SwitchCaseStatement>(testExpr, std::move(consequents));
+    caseNode->SetRange({caseStartLoc, caseEndLoc});
+    return caseNode;
+}
+
+ir::SwitchStatement *ParserImpl::ParseSwitchStatement()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+    if (!(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS)) {
+        ThrowSyntaxError("Unexpected token, expected '('");
+    }
+
+    lexer_->NextToken();
+    ir::Expression *discriminant = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+    if (!(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS)) {
+        ThrowSyntaxError("Unexpected token, expected ')'");
+    }
+
+    lexer_->NextToken();
+    SwitchContext switchContext(&context_);
+
+    if (!(lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE)) {
+        ThrowSyntaxError("Unexpected token, expected '{'");
+    }
+
+    lexer_->NextToken();
+    bool seenDefault = false;
+    auto localCtx = binder::LexicalScope<binder::LocalScope>(Binder());
+    ArenaVector<ir::SwitchCaseStatement *> cases(Allocator()->Adapter());
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        cases.push_back(ParseSwitchCaseStatement(&seenDefault));
+    }
+
+    auto *switchStatement = AllocNode<ir::SwitchStatement>(localCtx.GetScope(), discriminant, std::move(cases));
+    switchStatement->SetRange({startLoc, lexer_->GetToken().End()});
+    localCtx.GetScope()->BindNode(switchStatement);
+
+    lexer_->NextToken();
+
+    return switchStatement;
+}
+
+ir::ThrowStatement *ParserImpl::ParseThrowStatement()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().NewLine()) {
+        if (Extension() == ScriptExtension::JS) {
+            ThrowSyntaxError("Illegal newline after throw");
+        }
+
+        if (Extension() == ScriptExtension::TS) {
+            ThrowSyntaxError("Line break not permitted here");
+        }
+    }
+
+    ir::Expression *expression = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+    lexer::SourcePosition endLoc = expression->End();
+
+    auto *throwStatement = AllocNode<ir::ThrowStatement>(expression);
+    throwStatement->SetRange({startLoc, endLoc});
+    ConsumeSemicolon(throwStatement);
+
+    return throwStatement;
+}
+
+ir::Expression *ParserImpl::ParseCatchParam()
+{
+    ir::Expression *param = nullptr;
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        return param;
+    }
+
+    lexer_->NextToken();  // eat left paren
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT) {
+        switch (lexer_->GetToken().KeywordType()) {
+            case lexer::TokenType::KEYW_EVAL: {
+                ThrowSyntaxError("Binding 'eval' in strict mode is invalid");
+            }
+            case lexer::TokenType::KEYW_ARGUMENTS: {
+                ThrowSyntaxError("Binding 'arguments' in strict mode is invalid");
+            }
+            default: {
+                break;
+            }
+        }
+
+        param = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        param->SetRange(lexer_->GetToken().Loc());
+
+        lexer_->NextToken();
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET) {
+        param = ParseArrayExpression(ExpressionParseFlags::MUST_BE_PATTERN);
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        param = ParseObjectExpression(ExpressionParseFlags::MUST_BE_PATTERN);
+    } else {
+        ThrowSyntaxError("Unexpected token in catch parameter");
+    }
+
+    Binder()->AddParamDecl(param);
+
+    if (Extension() == ScriptExtension::TS) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+            lexer_->NextToken();  // eat ':'
+
+            TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+            param->SetTsTypeAnnotation(ParseTsTypeAnnotation(&options));
+        }
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+            ThrowSyntaxError("Catch clause variable cannot have an initializer");
+        }
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token, expected ')'");
+    }
+
+    lexer_->NextToken();
+
+    return param;
+}
+
+ir::CatchClause *ParserImpl::ParseCatchClause()
+{
+    lexer::SourcePosition catchStartLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat 'catch' keyword
+
+    auto catchParamCtx = binder::LexicalScope<binder::CatchParamScope>(Binder());
+    auto *catchParamScope = catchParamCtx.GetScope();
+
+    ir::Expression *param = ParseCatchParam();
+    catchParamScope->BindNode(param);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        ThrowSyntaxError("Unexpected token, expected '{'");
+    }
+
+    auto catchCtx = binder::LexicalScope<binder::CatchScope>(Binder());
+    auto *catchScope = catchCtx.GetScope();
+    catchScope->AssignParamScope(catchParamScope);
+
+    ir::BlockStatement *catchBlock = ParseBlockStatement(catchScope);
+    lexer::SourcePosition endLoc = catchBlock->End();
+
+    auto *catchClause = AllocNode<ir::CatchClause>(catchScope, param, catchBlock);
+    catchClause->SetRange({catchStartLoc, endLoc});
+    catchScope->BindNode(catchClause);
+
+    return catchClause;
+}
+
+ir::TryStatement *ParserImpl::ParseTryStatement()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer::SourcePosition endLoc = lexer_->GetToken().End();
+
+    lexer_->NextToken();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        ThrowSyntaxError("Unexpected token, expected '{'");
+    }
+
+    ir::BlockStatement *body = ParseBlockStatement();
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::KEYW_CATCH &&
+        lexer_->GetToken().Type() != lexer::TokenType::KEYW_FINALLY) {
+        ThrowSyntaxError("Missing catch or finally clause");
+    }
+
+    ir::CatchClause *catchClause = nullptr;
+    ir::BlockStatement *finnalyClause = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_CATCH) {
+        catchClause = ParseCatchClause();
+        endLoc = catchClause->End();
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_FINALLY) {
+        lexer_->NextToken();  // eat 'finally' keyword
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+            ThrowSyntaxError("Unexpected token, expected '{'");
+        }
+
+        finnalyClause = ParseBlockStatement();
+        endLoc = finnalyClause->End();
+    }
+
+    auto *tryStatement = AllocNode<ir::TryStatement>(body, catchClause, finnalyClause);
+    tryStatement->SetRange({startLoc, endLoc});
+    return tryStatement;
+}
+
+// TODO(frobert) : merge into lexer::LexerNextTokenFlags
+void ParserImpl::ValidateDeclaratorId()
+{
+    if (context_.Status() & ParserStatus::IN_AMBIENT_CONTEXT) {
+        return;
+    }
+
+    switch (lexer_->GetToken().KeywordType()) {
+        case lexer::TokenType::KEYW_AWAIT: {
+            if (context_.IsModule()) {
+                ThrowSyntaxError("'await' is not permitted as an identifier in module code");
+            }
+            break;
+        }
+        case lexer::TokenType::KEYW_EVAL: {
+            ThrowSyntaxError("Binding 'eval' in strict mode is invalid");
+        }
+        case lexer::TokenType::KEYW_ARGUMENTS: {
+            ThrowSyntaxError("Binding 'arguments' in strict mode is invalid");
+        }
+        case lexer::TokenType::KEYW_LET: {
+            ThrowSyntaxError("let is disallowed as a lexically bound name");
+            break;
+        }
+        case lexer::TokenType::KEYW_STATIC:
+        case lexer::TokenType::KEYW_IMPLEMENTS:
+        case lexer::TokenType::KEYW_INTERFACE:
+        case lexer::TokenType::KEYW_PACKAGE:
+        case lexer::TokenType::KEYW_PRIVATE:
+        case lexer::TokenType::KEYW_PROTECTED:
+        case lexer::TokenType::KEYW_PUBLIC:
+        case lexer::TokenType::KEYW_YIELD: {
+            ThrowSyntaxError("Unexpected reserved word");
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+ir::VariableDeclarator *ParserImpl::ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
+                                                                       const lexer::SourcePosition &startLoc,
+                                                                       bool isDeclare)
+{
+    if (flags & VariableParsingFlags::DISALLOW_INIT) {
+        ThrowSyntaxError("for-await-of loop variable declaration may not have an initializer");
+    }
+
+    lexer_->NextToken();
+
+    if (isDeclare && !(flags & VariableParsingFlags::CONST)) {
+        ThrowSyntaxError("Initializers are not allowed in ambient contexts.");
+    }
+
+    auto exprFlags =
+        ((flags & VariableParsingFlags::STOP_AT_IN) ? ExpressionParseFlags::STOP_AT_IN : ExpressionParseFlags::NO_OPTS);
+
+    ir::Expression *initializer = ParseExpression(exprFlags);
+    lexer::SourcePosition endLoc = initializer->End();
+
+    auto *declarator = AllocNode<ir::VariableDeclarator>(init, initializer);
+    declarator->SetRange({startLoc, endLoc});
+
+    return declarator;
+}
+
+ir::VariableDeclarator *ParserImpl::ParseVariableDeclarator(VariableParsingFlags flags, bool isDeclare)
+{
+    ir::Expression *init = nullptr;
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::LITERAL_IDENT: {
+            ValidateDeclaratorId();
+
+            if (!(flags & VariableParsingFlags::VAR) &&
+                lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_LET) {
+                ThrowSyntaxError("let is disallowed as a lexically bound name");
+            }
+
+            const util::StringView &identStr = lexer_->GetToken().Ident();
+            init = AllocNode<ir::Identifier>(identStr, Allocator());
+            init->SetRange(lexer_->GetToken().Loc());
+
+            lexer_->NextToken();
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET: {
+            init = ParseArrayExpression(ExpressionParseFlags::MUST_BE_PATTERN);
+            break;
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_BRACE: {
+            init = ParseObjectExpression(ExpressionParseFlags::MUST_BE_PATTERN);
+            break;
+        }
+        default: {
+            ThrowSyntaxError("Unexpected token in variable declaration");
+        }
+    }
+
+    if (Extension() == ScriptExtension::TS) {
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
+            lexer_->NextToken();  // eat ':'
+            TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
+            init->SetTsTypeAnnotation(ParseTsTypeAnnotation(&options));
+        }
+    }
+
+    ir::VariableDeclarator *declarator {};
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        declarator = ParseVariableDeclaratorInitializer(init, flags, startLoc, isDeclare);
+    } else {
+        if (!isDeclare && (flags & VariableParsingFlags::CONST) &&
+            !(flags & VariableParsingFlags::ACCEPT_CONST_NO_INIT) &&
+            !(context_.Status() & ParserStatus::IN_AMBIENT_CONTEXT)) {
+            ThrowSyntaxError("Missing initializer in const declaration");
+        }
+
+        lexer::SourcePosition endLoc = init->End();
+        declarator = AllocNode<ir::VariableDeclarator>(init);
+        declarator->SetRange({startLoc, endLoc});
+    }
+
+    std::vector<const ir::Identifier *> bindings = util::Helpers::CollectBindingNames(init);
+
+    for (const auto *binding : bindings) {
+        binder::Decl *decl = nullptr;
+
+        if (flags & VariableParsingFlags::VAR) {
+            decl = Binder()->AddDecl<binder::VarDecl>(startLoc, binding->Name());
+        } else if (flags & VariableParsingFlags::LET) {
+            decl = Binder()->AddDecl<binder::LetDecl>(startLoc, binding->Name());
+        } else {
+            decl = Binder()->AddDecl<binder::ConstDecl>(startLoc, binding->Name());
+        }
+
+        decl->BindNode(init);
+    }
+
+    return declarator;
+}
+
+ir::Statement *ParserImpl::ParseVariableDeclaration(VariableParsingFlags flags, bool isDeclare)
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+
+    if (!(flags & VariableParsingFlags::NO_SKIP_VAR_KIND)) {
+        lexer_->NextToken();
+    }
+
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_ENUM) {
+        if (!(flags & VariableParsingFlags::CONST)) {
+            ThrowSyntaxError("Variable declaration expected.");
+        }
+        return ParseEnumDeclaration(true);
+    }
+
+    ArenaVector<ir::VariableDeclarator *> declarators(Allocator()->Adapter());
+
+    while (true) {
+        ir::VariableDeclarator *declarator = ParseVariableDeclarator(flags, isDeclare);
+
+        declarators.push_back(declarator);
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_COMMA) {
+            break;
+        }
+        lexer_->NextToken();
+    }
+
+    auto varKind = ir::VariableDeclaration::VariableDeclarationKind::VAR;
+
+    if (flags & VariableParsingFlags::LET) {
+        varKind = ir::VariableDeclaration::VariableDeclarationKind::LET;
+    } else if (flags & VariableParsingFlags::CONST) {
+        varKind = ir::VariableDeclaration::VariableDeclarationKind::CONST;
+    }
+
+    lexer::SourcePosition endLoc = declarators.back()->End();
+    auto *declaration = AllocNode<ir::VariableDeclaration>(varKind, std::move(declarators), isDeclare);
+    declaration->SetRange({startLoc, endLoc});
+
+    return declaration;
+}
+
+ir::WhileStatement *ParserImpl::ParseWhileStatement()
+{
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token, expected '('");
+    }
+
+    lexer_->NextToken();
+    ir::Expression *test = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+        ThrowSyntaxError("Unexpected token, expected ')'");
+    }
+
+    lexer_->NextToken();
+    IterationContext<binder::LoopScope> iterCtx(&context_, Binder());
+    ir::Statement *body = ParseStatement();
+
+    lexer::SourcePosition endLoc = body->End();
+    auto *whileStatement = AllocNode<ir::WhileStatement>(iterCtx.LexicalScope().GetScope(), test, body);
+    whileStatement->SetRange({startLoc, endLoc});
+    iterCtx.LexicalScope().GetScope()->BindNode(whileStatement);
+
+    return whileStatement;
+}
+
+ir::ExportDefaultDeclaration *ParserImpl::ParseExportDefaultDeclaration(const lexer::SourcePosition &startLoc,
+                                                                        ArenaVector<ir::Decorator *> decorators,
+                                                                        bool isExportEquals)
+{
+    lexer_->NextToken();  // eat `default` keyword or `=`
+
+    ir::AstNode *declNode = nullptr;
+    bool eatSemicolon = false;
+
+    if (!decorators.empty() && lexer_->GetToken().Type() != lexer::TokenType::KEYW_CLASS &&
+        (context_.Status() & ParserStatus::IN_CLASS_BODY) == 0) {
+        ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
+    }
+
+    ExportDeclarationContext exportDeclCtx(Binder());
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_FUNCTION) {
+        declNode = ParseFunctionDeclaration(true);
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::KEYW_CLASS) {
+        declNode = ParseClassDeclaration(false, std::move(decorators));
+    } else if (lexer_->GetToken().IsAsyncModifier()) {
+        lexer_->NextToken();  // eat `async` keyword
+        declNode = ParseFunctionDeclaration(false, ParserStatus::ASYNC_FUNCTION);
+    } else if (Extension() == ScriptExtension::TS &&
+               lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_INTERFACE) {
+        declNode = ParseTsInterfaceDeclaration();
+    } else {
+        declNode = ParseExpression();
+        eatSemicolon = true;
+    }
+
+    lexer::SourcePosition endLoc = declNode->End();
+    auto *exportDeclaration = AllocNode<ir::ExportDefaultDeclaration>(declNode, isExportEquals);
+    exportDeclaration->SetRange({startLoc, endLoc});
+    exportDeclCtx.BindExportDecl(exportDeclaration);
+
+    if (eatSemicolon) {
+        ConsumeSemicolon(exportDeclaration);
+    }
+
+    return exportDeclaration;
+}
+
+ir::Identifier *ParserImpl::ParseNamedExport(const lexer::Token &exportedToken)
+{
+    if (exportedToken.Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Unexpected token, expected an identifier.");
+    }
+
+    const util::StringView &exportedString = exportedToken.Ident();
+
+    auto *exported = AllocNode<ir::Identifier>(exportedString, Allocator());
+    exported->SetRange(exportedToken.Loc());
+
+    return exported;
+}
+
+ir::ExportAllDeclaration *ParserImpl::ParseExportAllDeclaration(const lexer::SourcePosition &startLoc)
+{
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat `*` character
+
+    ir::Identifier *exported = nullptr;
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AS) {
+        lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+        exported = ParseNamedExport(lexer_->GetToken());
+        lexer_->NextToken();  // eat exported name
+    }
+
+    ir::StringLiteral *source = ParseFromClause();
+    lexer::SourcePosition endLoc = source->End();
+
+    auto *exportDeclaration = AllocNode<ir::ExportAllDeclaration>(source, exported);
+    exportDeclaration->SetRange({startLoc, endLoc});
+    auto *decl = Binder()->AddDecl<binder::ExportDecl>(startLoc, exported ? exported->Name() : "*", "*");
+    Binder()->GetScope()->AsModuleScope()->AddExportDecl(exportDeclaration, decl);
+
+    ConsumeSemicolon(exportDeclaration);
+
+    return exportDeclaration;
+}
+
+ir::ExportNamedDeclaration *ParserImpl::ParseExportNamedSpecifiers(const lexer::SourcePosition &startLoc)
+{
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat `{` character
+
+    ArenaVector<ir::ExportSpecifier *> specifiers(Allocator()->Adapter());
+    binder::ModuleScope::ExportDeclList exportDecls(Allocator()->Adapter());
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+            ThrowSyntaxError("Unexpected token");
+        }
+
+        lexer::Token localToken = lexer_->GetToken();
+        auto *local = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        local->SetRange(lexer_->GetToken().Loc());
+
+        lexer_->NextToken();  // eat local name
+
+        ir::Identifier *exported = nullptr;
+
+        if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AS) {
+            lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat `as` literal
+            exported = ParseNamedExport(lexer_->GetToken());
+            lexer_->NextToken();  // eat exported name
+        } else {
+            exported = ParseNamedExport(localToken);
+        }
+
+        auto *specifier = AllocNode<ir::ExportSpecifier>(local, exported);
+        specifier->SetRange({local->Start(), exported->End()});
+
+        specifiers.push_back(specifier);
+        auto *decl = Binder()->AddDecl<binder::ExportDecl>(startLoc, exported->Name(), local->Name(), specifier);
+        exportDecls.push_back(decl);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat comma
+        }
+    }
+
+    lexer::SourcePosition endPos = lexer_->GetToken().End();
+    lexer_->NextToken();  // eat right brace
+
+    ir::StringLiteral *source = nullptr;
+
+    if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_FROM) {
+        source = ParseFromClause();
+    }
+
+    auto *exportDeclaration = AllocNode<ir::ExportNamedDeclaration>(source, std::move(specifiers));
+    exportDeclaration->SetRange({startLoc, endPos});
+    Binder()->GetScope()->AsModuleScope()->AddExportDecl(exportDeclaration, std::move(exportDecls));
+    ConsumeSemicolon(exportDeclaration);
+
+    return exportDeclaration;
+}
+
+ir::ExportNamedDeclaration *ParserImpl::ParseNamedExportDeclaration(const lexer::SourcePosition &startLoc,
+                                                                    ArenaVector<ir::Decorator *> &&decorators)
+{
+    ir::Statement *decl = nullptr;
+
+    bool isDeclare = false;
+
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_DECLARE) {
+        CheckDeclare();
+        isDeclare = true;
+    }
+
+    if (!decorators.empty() && lexer_->GetToken().Type() != lexer::TokenType::KEYW_CLASS &&
+        (context_.Status() & ParserStatus::IN_CLASS_BODY) == 0) {
+        ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
+    }
+
+    ExportDeclarationContext exportDeclCtx(Binder());
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::KEYW_VAR: {
+            decl = ParseVariableDeclaration(VariableParsingFlags::VAR, isDeclare);
+            break;
+        }
+        case lexer::TokenType::KEYW_CONST: {
+            decl = ParseVariableDeclaration(VariableParsingFlags::CONST, isDeclare);
+            break;
+        }
+        case lexer::TokenType::KEYW_LET: {
+            decl = ParseVariableDeclaration(VariableParsingFlags::LET, isDeclare);
+            break;
+        }
+        case lexer::TokenType::KEYW_FUNCTION: {
+            decl = ParseFunctionDeclaration(false, ParserStatus::NO_OPTS, isDeclare);
+            break;
+        }
+        case lexer::TokenType::KEYW_CLASS: {
+            decl = ParseClassDeclaration(true, std::move(decorators), isDeclare);
+            break;
+        }
+        case lexer::TokenType::LITERAL_IDENT: {
+            if (Extension() == ScriptExtension::TS) {
+                switch (lexer_->GetToken().KeywordType()) {
+                    case lexer::TokenType::KEYW_LET: {
+                        decl = ParseVariableDeclaration(VariableParsingFlags::LET, isDeclare);
+                        break;
+                    }
+                    case lexer::TokenType::KEYW_ENUM: {
+                        decl = ParseEnumDeclaration();
+                        break;
+                    }
+                    case lexer::TokenType::KEYW_INTERFACE: {
+                        decl = ParseTsInterfaceDeclaration();
+                        break;
+                    }
+                    case lexer::TokenType::KEYW_TYPE: {
+                        decl = ParseTsTypeAliasDeclaration(isDeclare);
+                        break;
+                    }
+                    case lexer::TokenType::KEYW_GLOBAL:
+                    case lexer::TokenType::KEYW_MODULE:
+                    case lexer::TokenType::KEYW_NAMESPACE: {
+                        auto savedStatus = context_.Status();
+                        if (isDeclare) {
+                            context_.Status() |= ParserStatus::IN_AMBIENT_CONTEXT;
+                        }
+                        decl = ParseTsModuleDeclaration(isDeclare);
+                        context_.Status() = savedStatus;
+                        break;
+                    }
+                    default: {
+                        break;
+                    }
+                }
+
+                if (decl) {
+                    break;
+                }
+            }
+
+            [[fallthrough]];
+        }
+        default: {
+            if (!lexer_->GetToken().IsAsyncModifier()) {
+                ThrowSyntaxError("Unexpected token");
+            }
+
+            lexer_->NextToken();  // eat `async` keyword
+            decl = ParseFunctionDeclaration(false, ParserStatus::ASYNC_FUNCTION);
+        }
+    }
+
+    if (decl->IsVariableDeclaration()) {
+        ConsumeSemicolon(decl);
+    }
+
+    lexer::SourcePosition endLoc = decl->End();
+    ArenaVector<ir::ExportSpecifier *> specifiers(Allocator()->Adapter());
+    auto *exportDeclaration = AllocNode<ir::ExportNamedDeclaration>(decl, std::move(specifiers));
+    exportDeclaration->SetRange({startLoc, endLoc});
+
+    exportDeclCtx.BindExportDecl(exportDeclaration);
+
+    return exportDeclaration;
+}
+
+ir::Statement *ParserImpl::ParseExportDeclaration(StatementParsingFlags flags,
+                                                  ArenaVector<ir::Decorator *> &&decorators)
+{
+    if (Extension() == ScriptExtension::JS) {
+        if (!(flags & StatementParsingFlags::GLOBAL)) {
+            ThrowSyntaxError("'import' and 'export' may only appear at the top level");
+        }
+
+        if (!context_.IsModule()) {
+            ThrowSyntaxError("'import' and 'export' may appear only with 'sourceType: module'");
+        }
+    }
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat `export` keyword
+
+    switch (lexer_->GetToken().Type()) {
+        case lexer::TokenType::KEYW_DEFAULT: {
+            return ParseExportDefaultDeclaration(startLoc, std::move(decorators));
+        }
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY: {
+            return ParseExportAllDeclaration(startLoc);
+        }
+        case lexer::TokenType::PUNCTUATOR_LEFT_BRACE: {
+            return ParseExportNamedSpecifiers(startLoc);
+        }
+        case lexer::TokenType::KEYW_IMPORT: {
+            return ParseTsImportEqualsDeclaration(startLoc, true);
+        }
+        case lexer::TokenType::PUNCTUATOR_SUBSTITUTION: {
+            if (Extension() == ScriptExtension::TS) {
+                return ParseExportDefaultDeclaration(startLoc, std::move(decorators), true);
+            }
+
+            [[fallthrough]];
+        }
+        default: {
+            ir::ExportNamedDeclaration *exportDecl = ParseNamedExportDeclaration(startLoc, std::move(decorators));
+
+            if (Extension() == ScriptExtension::TS && exportDecl->Decl()->IsVariableDeclaration() &&
+                !(flags & StatementParsingFlags::GLOBAL) && exportDecl->Parent() &&
+                !exportDecl->Parent()->IsTSModuleBlock() && !context_.IsModule()) {
+                ThrowSyntaxError("Modifiers cannot appear here'");
+            }
+
+            return exportDecl;
+        }
+    }
+}
+
+void ParserImpl::ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers)
+{
+    lexer::SourcePosition namespaceStart = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat `*` character
+
+    if (lexer_->GetToken().KeywordType() != lexer::TokenType::KEYW_AS) {
+        ThrowSyntaxError("Unexpected token.");
+    }
+
+    lexer_->NextToken();  // eat `as` literal
+
+    ir::Identifier *local = ParseNamedImport(lexer_->GetToken());
+
+    auto *specifier = AllocNode<ir::ImportNamespaceSpecifier>(local);
+    specifier->SetRange({namespaceStart, lexer_->GetToken().End()});
+    specifiers->push_back(specifier);
+
+    Binder()->AddDecl<binder::ImportDecl>(namespaceStart, "*", local->Name(), specifier);
+
+    lexer_->NextToken();  // eat local name
+}
+
+ir::Identifier *ParserImpl::ParseNamedImport(const lexer::Token &importedToken)
+{
+    if (importedToken.Type() != lexer::TokenType::LITERAL_IDENT) {
+        ThrowSyntaxError("Unexpected token");
+    }
+
+    switch (importedToken.KeywordType()) {
+        case lexer::TokenType::KEYW_EVAL: {
+            ThrowSyntaxError("Binding 'eval' in strict mode is invalid");
+        }
+        case lexer::TokenType::KEYW_ARGUMENTS: {
+            ThrowSyntaxError("Binding 'arguments' in strict mode is invalid");
+        }
+        default: {
+            break;
+        }
+    }
+
+    auto *local = AllocNode<ir::Identifier>(importedToken.Ident(), Allocator());
+    local->SetRange(importedToken.Loc());
+
+    return local;
+}
+
+void ParserImpl::ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers)
+{
+    lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat `{` character
+
+    while (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_BRACE) {
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+            ThrowSyntaxError("Unexpected token");
+        }
+
+        lexer::Token importedToken = lexer_->GetToken();
+        auto *imported = AllocNode<ir::Identifier>(importedToken.Ident(), Allocator());
+        ir::Identifier *local = nullptr;
+        imported->SetRange(lexer_->GetToken().Loc());
+
+        lexer_->NextToken();  // eat import name
+
+        if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AS) {
+            lexer_->NextToken();  // eat `as` literal
+            local = ParseNamedImport(lexer_->GetToken());
+            lexer_->NextToken();  // eat local name
+        } else {
+            local = ParseNamedImport(importedToken);
+        }
+
+        auto *specifier = AllocNode<ir::ImportSpecifier>(imported, local);
+        specifier->SetRange({imported->Start(), local->End()});
+        specifiers->push_back(specifier);
+
+        Binder()->AddDecl<binder::ImportDecl>(imported->Start(), imported->Name(), local->Name(), specifier);
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+            lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);  // eat comma
+        }
+    }
+
+    lexer_->NextToken();  // eat right brace
+}
+
+ir::Expression *ParserImpl::ParseModuleReference()
+{
+    ir::Expression *result = nullptr;
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
+        lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_REQUIRE &&
+        lexer_->Lookahead() == LEX_CHAR_LEFT_PAREN) {
+        lexer::SourcePosition start = lexer_->GetToken().Start();
+        lexer_->NextToken();  // eat 'require'
+        lexer_->NextToken();  // eat '('
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_STRING) {
+            ThrowSyntaxError("String literal expected.");
+        }
+
+        result = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+        result->SetRange(lexer_->GetToken().Loc());
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS) {
+            ThrowSyntaxError("')' expected.");
+        }
+
+        result = AllocNode<ir::TSExternalModuleReference>(result);
+        result->SetRange({start, lexer_->GetToken().End()});
+        lexer_->NextToken();  // eat ')'
+    } else {
+        result = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+        result->SetRange(lexer_->GetToken().Loc());
+        lexer_->NextToken();
+
+        if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_PERIOD) {
+            result = ParseTsQualifiedReference(result);
+        }
+    }
+
+    return result;
+}
+
+ir::AstNode *ParserImpl::ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers)
+{
+    ir::Identifier *local = ParseNamedImport(lexer_->GetToken());
+    lexer_->NextToken();  // eat local name
+
+    if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+        lexer_->NextToken();  // eat substitution
+        if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) {
+            ThrowSyntaxError("identifier expected");
+        }
+
+        auto *importEqualsDecl = AllocNode<ir::TSImportEqualsDeclaration>(local, ParseModuleReference(), false);
+
+        return importEqualsDecl;
+    }
+
+    auto *specifier = AllocNode<ir::ImportDefaultSpecifier>(local);
+    specifier->SetRange(specifier->Local()->Range());
+    specifiers->push_back(specifier);
+
+    Binder()->AddDecl<binder::ImportDecl>(local->Start(), "default", local->Name(), specifier);
+
+    lexer_->NextToken();  // eat specifier name
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA) {
+        lexer_->NextToken();  // eat comma
+    }
+
+    return nullptr;
+}
+
+ir::StringLiteral *ParserImpl::ParseFromClause(bool requireFrom)
+{
+    if (lexer_->GetToken().KeywordType() != lexer::TokenType::KEYW_FROM) {
+        if (requireFrom) {
+            ThrowSyntaxError("Unexpected token.");
+        }
+    } else {
+        lexer_->NextToken();  // eat `from` literal
+    }
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_STRING) {
+        ThrowSyntaxError("Unexpected token.");
+    }
+
+    ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING);
+
+    auto *source = AllocNode<ir::StringLiteral>(lexer_->GetToken().String());
+    source->SetRange(lexer_->GetToken().Loc());
+
+    lexer_->NextToken();
+
+    return source;
+}
+
+ir::AstNode *ParserImpl::ParseImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers)
+{
+    ASSERT(specifiers->empty());
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT) {
+        ir::AstNode *astNode = ParseImportDefaultSpecifier(specifiers);
+        if (astNode != nullptr) {
+            return astNode;
+        }
+    }
+
+    if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MULTIPLY) {
+        ParseNameSpaceImport(specifiers);
+    } else if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
+        ParseNamedImportSpecifiers(specifiers);
+    }
+    return nullptr;
+}
+
+ir::Statement *ParserImpl::ParseImportDeclaration(StatementParsingFlags flags)
+{
+    ImportDeclarationContext importCtx(Binder());
+
+    if (Extension() == ScriptExtension::JS) {
+        if (!(flags & StatementParsingFlags::GLOBAL)) {
+            ThrowSyntaxError("'import' and 'export' may only appear at the top level");
+        }
+
+        if (!context_.IsModule()) {
+            ThrowSyntaxError("'import' and 'export' may appear only with 'sourceType: module'");
+        }
+    }
+
+    char32_t nextChar = lexer_->Lookahead();
+    if (nextChar == LEX_CHAR_LEFT_PAREN || nextChar == LEX_CHAR_DOT) {
+        return ParseExpressionStatement();
+    }
+
+    lexer::SourcePosition startLoc = lexer_->GetToken().Start();
+    lexer_->NextToken();  // eat import
+
+    ArenaVector<ir::AstNode *> specifiers(Allocator()->Adapter());
+
+    ir::StringLiteral *source = nullptr;
+
+    if (lexer_->GetToken().Type() != lexer::TokenType::LITERAL_STRING) {
+        ir::AstNode *astNode = ParseImportSpecifiers(&specifiers);
+        if (astNode != nullptr) {
+            ASSERT(astNode->IsTSImportEqualsDeclaration());
+            astNode->SetRange({startLoc, lexer_->GetToken().End()});
+            ConsumeSemicolon(astNode->AsTSImportEqualsDeclaration());
+            return astNode->AsTSImportEqualsDeclaration();
+        }
+        source = ParseFromClause(true);
+    } else {
+        source = ParseFromClause(false);
+    }
+
+    lexer::SourcePosition endLoc = source->End();
+    auto *importDeclaration = AllocNode<ir::ImportDeclaration>(source, std::move(specifiers));
+    importDeclaration->SetRange({startLoc, endLoc});
+    importCtx.BindImportDecl(importDeclaration);
+
+    ConsumeSemicolon(importDeclaration);
+
+    return importDeclaration;
+}
+
+}  // namespace panda::es2panda::parser
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_1-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..288740e954dfa756c74d3d80e5ca46fe5d32f842
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_1-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_1.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_1.ts b/es2panda/test/compiler/ts/arithmetic_operators_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..684252af5e6795e181eb91c192fb56a491825b38
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a - "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_10-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6162e8d65e422955268411a164e63b855dd36855
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_10-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_10.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_10.ts b/es2panda/test/compiler/ts/arithmetic_operators_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3fc3b8631f274d8954b0af07ed06316fb2f7209b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a / "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_11-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dc3cc3dd1c90c6543d4f71ab74870015620f4b04
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_11-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_11.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_11.ts b/es2panda/test/compiler/ts/arithmetic_operators_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a8ec87252a5d789302b33af7b07a4e96956bf91b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a / 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_12-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8456c97e27ef0bed8cfd5b78e2db47761bdc410f
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_12-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_12.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_12.ts b/es2panda/test/compiler/ts/arithmetic_operators_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d2559c5504f9ab94ecbb0ded31850aff73b6b675
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a / false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_13-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3752048af1cacb1c57ab2cdd3e4f6f4f56414767
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_13-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_13.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_13.ts b/es2panda/test/compiler/ts/arithmetic_operators_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fecd16b6c99cb2d52db3fe15bac8e3599282dcb1
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_13.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a % "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_14-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2337dee5fb04331d2c6ef16bda0c6e44192e19ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_14-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_14.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_14.ts b/es2panda/test/compiler/ts/arithmetic_operators_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aa2f39bb7a7d3232e6539fe861f679b3380b6989
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_14.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a % 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_15-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a3fc607bce8b56652f49c9c121a06f98cd53e24e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_15-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_15.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_15.ts b/es2panda/test/compiler/ts/arithmetic_operators_15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b3eb8e2c16b93dc1468db405664a441917372f84
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_15.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a % false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_16-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dd4bae102ab896f16683b30976d0fd3f157d4c9f
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_16-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 5
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_16.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_16.ts b/es2panda/test/compiler/ts/arithmetic_operators_16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..203477f7449ba3cae576fef04e5a0244e8943943
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_16.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a++;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_17-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3196beb0513b52dd2cf0faf3da2a82f28ec667b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_17-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "--",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 5
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_17.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_17.ts b/es2panda/test/compiler/ts/arithmetic_operators_17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8e428925cca89c20b858cb321df887a4bd1a63fe
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_17.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a--;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_18-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ae420d50fa74889b571ef0c76a95ff823ddddf4e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_18-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_18.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_18.ts b/es2panda/test/compiler/ts/arithmetic_operators_18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e63501e9ddfe1b9cd8cc644cc867f8f823bfd805
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_18.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a - "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_19-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f76c937060d15b38969d7c10df869608060d57aa
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_19-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_19.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_19.ts b/es2panda/test/compiler/ts/arithmetic_operators_19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3e5e9bc02a2bbb69012f700d7b61096089446beb
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_19.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a - false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_2-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d263e6e4da163b0024e9dcec8a530a24431bdd4a
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_2-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_2.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_2.ts b/es2panda/test/compiler/ts/arithmetic_operators_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6c29c14302614372760486bf01414215b24db43c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a - 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_20-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..731f50e391933511acaf5ae8e24f3dc738630744
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_20-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_20.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_20.ts b/es2panda/test/compiler/ts/arithmetic_operators_20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2adebd1b4b05a4b0eb728ae899e6e27069761b7
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_20.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a * "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_21-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_21-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6dde73b29a61e93c44f4aca6f9b5427809d69b84
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_21-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_21.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_21.ts b/es2panda/test/compiler/ts/arithmetic_operators_21.ts
new file mode 100644
index 0000000000000000000000000000000000000000..84c12afaec4e3e60d24e4484c17077450c5184a8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_21.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a * false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_22-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_22-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0074500f0363cd7ba3379d8a807cb0104dbb7a69
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_22-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_22.ts:3:6]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_22.ts b/es2panda/test/compiler/ts/arithmetic_operators_22.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8d10f0f047dbfdad906a4c64de4b98d435467dd7
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_22.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a ** "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_23-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_23-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dfc577e888171dca1e195d6ded51715c85973b25
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_23-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_23.ts:3:6]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_23.ts b/es2panda/test/compiler/ts/arithmetic_operators_23.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a26291eb2cfb0dc3e67e8c05074db7550cc497c3
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_23.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a ** false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_24-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_24-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..299582411967ba5fb2133d9b422b5751f019ac3b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_24-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_24.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_24.ts b/es2panda/test/compiler/ts/arithmetic_operators_24.ts
new file mode 100644
index 0000000000000000000000000000000000000000..003989c1d12a3749eaec204ac856b0117d0d031d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_24.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a / "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_25-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_25-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..86996891d492fea28bdb6eed721026d6f3be177a
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_25-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_25.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_25.ts b/es2panda/test/compiler/ts/arithmetic_operators_25.ts
new file mode 100644
index 0000000000000000000000000000000000000000..da858c2c349627909a1b07936b712b01711241bf
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_25.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a / false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_26-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_26-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e3f2d0f987305422ca20ebf79a02569d4d63f831
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_26-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_26.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_26.ts b/es2panda/test/compiler/ts/arithmetic_operators_26.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5ccc7a64a92018fa1d75b607876522eed442d1b4
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_26.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a % "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_27-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_27-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4f341159b7a0a7b0dbc51114199cc8510906cc3a
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_27-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_27.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_27.ts b/es2panda/test/compiler/ts/arithmetic_operators_27.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cbde4a6680acef33343a8bbd5414b3c97b07427d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_27.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+a % false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_28-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_28-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d55cccd29b846b1b9e7dc61d443a04750eea4582
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_28-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_28.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_28.ts b/es2panda/test/compiler/ts/arithmetic_operators_28.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c4a7e16739459544c571507d623602ca97792f4d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_28.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a + "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_29-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_29-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ee063d74163c823dca9811fda0ad0c2fe485e1ad
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_29-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_29.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_29.ts b/es2panda/test/compiler/ts/arithmetic_operators_29.ts
new file mode 100644
index 0000000000000000000000000000000000000000..83d027f5cdd5e77c91ffbd6c8d3c5dee69c0fc83
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_29.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a + 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_3-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b29a1990d29ee657304c639435bbcd8706fd5c84
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_3-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_3.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_3.ts b/es2panda/test/compiler/ts/arithmetic_operators_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..21e6e08be04b572a2d202f7bc66f5b594732884b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a - false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_30-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_30-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2677cbe71418f159db3ac1b9b956e08e669480a9
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_30-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_30.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_30.ts b/es2panda/test/compiler/ts/arithmetic_operators_30.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6fb03d3f4834e9821d081a815db60cd31fa8472b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_30.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a + false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_31-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_31-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..947308bc7f9c717da0b6350fcab4677cf05948b7
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_31-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_31.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_31.ts b/es2panda/test/compiler/ts/arithmetic_operators_31.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b7f238f5e712773ea6f1170523557d18928a0d47
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_31.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a - "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_32-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_32-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8d2917c3c28c553f879c252cc09d40c89e6e93b6
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_32-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_32.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_32.ts b/es2panda/test/compiler/ts/arithmetic_operators_32.ts
new file mode 100644
index 0000000000000000000000000000000000000000..625ffeaf6a7fce02cd647ad3981e1d333bfe599d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_32.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a - 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_33-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_33-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f8dcb01986b00a148394b666e2f159c3e203c114
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_33-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_33.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_33.ts b/es2panda/test/compiler/ts/arithmetic_operators_33.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0c235e5370423f51d7b7ce98d85a8e11f5a0621c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_33.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a - false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_34-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_34-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6a2d19fa223f3a9b96ed9c9d0b6459b7a289b086
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_34-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_34.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_34.ts b/es2panda/test/compiler/ts/arithmetic_operators_34.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c35c5dbfe1d987f553a1606505dad552e087fbe2
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_34.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a * "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_35-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_35-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a5d13fd528517aa59873176c6c17f710e06e361
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_35-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_35.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_35.ts b/es2panda/test/compiler/ts/arithmetic_operators_35.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3e09c01f7623952e66f8e6d32a9a871a814f58e6
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_35.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a * 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_36-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_36-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..71d419b4cffb0a4a815b78335c777a1d1176142d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_36-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_36.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_36.ts b/es2panda/test/compiler/ts/arithmetic_operators_36.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5d51c4fe9d61105628a989b1680324161b6d82ea
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_36.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a * false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_37-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_37-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1cf8806a0c56f6ddf167dece88bfdeabd0f4683e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_37-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_37.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_37.ts b/es2panda/test/compiler/ts/arithmetic_operators_37.ts
new file mode 100644
index 0000000000000000000000000000000000000000..45e84a31eabb232212b00912451adbb2b21fa548
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_37.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a ** "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_38-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_38-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..684ace52a569d2265d1ca97652719561dddd1df5
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_38-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_38.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_38.ts b/es2panda/test/compiler/ts/arithmetic_operators_38.ts
new file mode 100644
index 0000000000000000000000000000000000000000..07e9fc25d3142bcb0ff38e08530d13c1a449e999
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_38.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a ** 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_39-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_39-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d46f312226b132aa497e76a02cde76d8ec4d9ab
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_39-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_39.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_39.ts b/es2panda/test/compiler/ts/arithmetic_operators_39.ts
new file mode 100644
index 0000000000000000000000000000000000000000..73610174ef878f8fb722451ef6d97579a71f7383
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_39.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a ** false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_4-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1f3a61ca1554f4f1bfdd18a9ee3f67b7610f07bf
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_4-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_4.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_4.ts b/es2panda/test/compiler/ts/arithmetic_operators_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..59f55ca08ee6641d40ac831407d2920b4de9011b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a * "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_40-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_40-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c1821d66f1a2aa2db5f09a33528153f9f7aaedf4
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_40-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_40.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_40.ts b/es2panda/test/compiler/ts/arithmetic_operators_40.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2c2eaded30d033d5abdbe985cc20a35000fbfed6
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_40.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a / "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_41-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_41-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ab612f004716a80406b91b13d119034efd348ac5
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_41-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_41.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_41.ts b/es2panda/test/compiler/ts/arithmetic_operators_41.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e8f740163104722577653e344ad8d5c6dee21f8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_41.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a / 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_42-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_42-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9695e4ab4f5ee74c73845874f662d264662a7173
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_42-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_42.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_42.ts b/es2panda/test/compiler/ts/arithmetic_operators_42.ts
new file mode 100644
index 0000000000000000000000000000000000000000..67d21dfb6f4fc13b761c97eeb7e9fe91c7311136
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_42.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a / false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_43-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_43-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bff8397b9743a492dc2ae251e33c30c8c3848593
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_43-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_43.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_43.ts b/es2panda/test/compiler/ts/arithmetic_operators_43.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fbac11e8ff5985605962423e123cb53a83619c70
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_43.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a % "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_44-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_44-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d9dde9b9196c50666dc6c679533256e5dbc2f510
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_44-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_44.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_44.ts b/es2panda/test/compiler/ts/arithmetic_operators_44.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c80ac541a2cfdceb9bdd71ef21edffaf092cc6e8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_44.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a % 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_45-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_45-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..62d25f31f6160e7f4a8f19df284d4cb1314b2e24
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_45-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_45.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_45.ts b/es2panda/test/compiler/ts/arithmetic_operators_45.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a8dfc8685e2abc87cdf5b16f769e7106f115b3de
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_45.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a % false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_46-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_46-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3e9ce0b9f6cea43fa1f96f72fe162aa07382a2ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_46-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 5
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_46.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_46.ts b/es2panda/test/compiler/ts/arithmetic_operators_46.ts
new file mode 100644
index 0000000000000000000000000000000000000000..89b364dc5deb4cab042b272d5130034952964fde
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_46.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a++;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_47-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_47-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..565b17be094ebd169cf87bf1a541a10a9987a3fc
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_47-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "--",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 5
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [arithmetic_operators_47.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_47.ts b/es2panda/test/compiler/ts/arithmetic_operators_47.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e01fa452e2dac1b0f2df7bd0355151a6a26dfa11
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_47.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5;
+a--;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_48-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_48-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e0c0831c4e64cb8795d5e337996a1e325d447fd6
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_48-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_48.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_48.ts b/es2panda/test/compiler/ts/arithmetic_operators_48.ts
new file mode 100644
index 0000000000000000000000000000000000000000..36ad7d2b9880abc5fe140db4ad89022c3af2a7c9
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_48.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a - "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_49-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_49-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f05a3a691053fe58c6b05da11b49e7fad341d34f
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_49-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_49.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_49.ts b/es2panda/test/compiler/ts/arithmetic_operators_49.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6ad0aa3475156d731e4d3988a573a49d658332d1
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_49.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a - 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_5-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fb94f41021c29ee945b3bf5f135788e884faf2a8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_5-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_5.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_5.ts b/es2panda/test/compiler/ts/arithmetic_operators_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..35f7bffe1b75ce3c0fd61c4314b7fbc4d9b42bfa
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a * 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_50-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_50-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..10e76d91a5cfd1c1d881ed119a8aacd111f2c61a
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_50-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_50.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_50.ts b/es2panda/test/compiler/ts/arithmetic_operators_50.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c96523bbfea4523bc9bba840de11eb9c3419e4db
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_50.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a - false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_51-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_51-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aba79ac939065de59b9cc03e0ff9b67f00ff7bc0
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_51-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_51.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_51.ts b/es2panda/test/compiler/ts/arithmetic_operators_51.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df29f3b299cdf08ee39c4845737c423db9195ba5
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_51.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a * "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_52-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_52-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ac75c77df82ed9c9acf5acf4efed7d6a74632f9
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_52-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_52.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_52.ts b/es2panda/test/compiler/ts/arithmetic_operators_52.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f2ae1c3c0c25263faa5b00f34f7d9f8120b36886
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_52.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a * 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_53-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_53-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8fa0f9f1c1702b41f87b347bd5999304ab7f5bbc
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_53-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_53.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_53.ts b/es2panda/test/compiler/ts/arithmetic_operators_53.ts
new file mode 100644
index 0000000000000000000000000000000000000000..786d16466db4538e4dcd13bf39ceb7ae1e48dc39
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_53.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a * false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_54-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_54-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..943e245d8b1c7f291cb321d29bee9c8563a737c1
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_54-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_54.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_54.ts b/es2panda/test/compiler/ts/arithmetic_operators_54.ts
new file mode 100644
index 0000000000000000000000000000000000000000..567bda68084c0a88c37ebc0d826cf068f4d1dfcc
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_54.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a ** "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_55-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_55-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4e4995902b21158534e9fff50851fc02f87ba3d2
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_55-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_55.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_55.ts b/es2panda/test/compiler/ts/arithmetic_operators_55.ts
new file mode 100644
index 0000000000000000000000000000000000000000..897e7979b72414cf60496459555fcdc120859ddf
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_55.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a ** 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_56-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_56-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aa69aa412ca6d2c4b4b47c3f995d6e05af583ad6
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_56-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_56.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_56.ts b/es2panda/test/compiler/ts/arithmetic_operators_56.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2f280e4e77962c01cabbccd1a56ec1ab3326df3b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_56.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a ** false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_57-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_57-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..78a65f4e0a4c7f13b457521ed30601932612b339
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_57-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_57.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_57.ts b/es2panda/test/compiler/ts/arithmetic_operators_57.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0226b2535eeaff7e87da34e6281d2c5c81d500cb
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_57.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a / "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_58-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_58-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5268a57f656e5cd1bcc99ee73f28f0c5a183b93f
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_58-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_58.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_58.ts b/es2panda/test/compiler/ts/arithmetic_operators_58.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56210cca9e4eeb256cae368290e4a7ed8eb681b0
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_58.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a / 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_59-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_59-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4e1f24fae256423a3e5104d02b27c73996b68ab4
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_59-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_59.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_59.ts b/es2panda/test/compiler/ts/arithmetic_operators_59.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0126bf568b3e6ee34e2946ba1f541efb479231aa
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_59.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a / false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_6-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..47907576123402ee625284510b8d7fc607530022
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_6-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_6.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_6.ts b/es2panda/test/compiler/ts/arithmetic_operators_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2d151b3abd3fa70d66e66376eb59c83107067a89
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_6.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a * false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_60-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_60-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3899e9c05e26ecfe45106aed72929b32873c5f3d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_60-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_60.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_60.ts b/es2panda/test/compiler/ts/arithmetic_operators_60.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3af396349d61f5ee96440acbd210383e75284169
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_60.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a % "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_61-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_61-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3b08cb1e20711eeacfb6beefda47698fffc7b100
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_61-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_61.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_61.ts b/es2panda/test/compiler/ts/arithmetic_operators_61.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7da46ac2e1b1d5b87016f9b5d2f08d4fd65311a1
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_61.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a % 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_62-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_62-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..59b10a5615c03c3421a8cbe83b90bfb2179b012f
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_62-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_62.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_62.ts b/es2panda/test/compiler/ts/arithmetic_operators_62.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d31ad7aaee0bd18023f38015ce0b17888ba089c8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_62.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a % false;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_63-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_63-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bdf93a23c7b6733063480df0d1ffc47af8ef79d9
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_63-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 5
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_63.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_63.ts b/es2panda/test/compiler/ts/arithmetic_operators_63.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4c9495cf239ffb23b2bc3999a158268bb812f9d8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_63.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a++;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_64-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_64-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a3331079de562d94667735b4a71f66a72f82af09
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_64-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "--",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 5
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_64.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_64.ts b/es2panda/test/compiler/ts/arithmetic_operators_64.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a823b7990567ea14e3d38ad693e1cc53fed2b92
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_64.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+a--;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_7-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..edd8b712afddec2061fca09259c403ecad89ff69
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_7-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_7.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_7.ts b/es2panda/test/compiler/ts/arithmetic_operators_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..515ad0dd9144e66afe476ea6ac6ddd722edd2768
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a ** "foo";
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_8-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..82f721436065741d383d1787a6463c7561e3e465
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_8-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_8.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_8.ts b/es2panda/test/compiler/ts/arithmetic_operators_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1c2f8f08a5427c79958623e962d9c53927723108
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a ** 5;
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_9-expected.txt b/es2panda/test/compiler/ts/arithmetic_operators_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8cf64c587daff767666f3286db2359a37b4f900c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_9-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. [arithmetic_operators_9.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arithmetic_operators_9.ts b/es2panda/test/compiler/ts/arithmetic_operators_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5f594a42176dd44ae4cb69d12edc9635e5fc4649
--- /dev/null
+++ b/es2panda/test/compiler/ts/arithmetic_operators_9.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+a ** false;
diff --git a/es2panda/test/compiler/ts/arrayDestructuring-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..11f8d66c2c0eb6dbb16ef64172563178101936da
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring-expected.txt
@@ -0,0 +1,8484 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "var1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "var2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 16
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 17
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 35
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 20
+              },
+              "end": {
+                "line": 1,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 36
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 8
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var3",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 11
+                },
+                "end": {
+                  "line": 5,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var4",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 11
+                },
+                "end": {
+                  "line": 6,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "var3",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "OmittedExpression",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 13
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "var4",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 19
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "var1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 27
+                  }
+                }
+              },
+              {
+                "type": "OmittedExpression",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 30
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 35
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 22
+              },
+              "end": {
+                "line": 7,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 36
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var5",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 10
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 14
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 14
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 15
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 18
+              },
+              "end": {
+                "line": 9,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var5",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 26
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 11
+                },
+                "end": {
+                  "line": 10,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var6",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 10
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 14
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var7",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 20
+                    }
+                  }
+                },
+                "right": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 28
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 28
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var8",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 34
+                    }
+                  }
+                },
+                "right": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 41
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 41
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 42
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 45
+              },
+              "end": {
+                "line": 12,
+                "column": 47
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 5
+            },
+            "end": {
+              "line": 12,
+              "column": 47
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 48
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var6",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 11
+                },
+                "end": {
+                  "line": 13,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 5
+            },
+            "end": {
+              "line": 13,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var7",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 11
+                },
+                "end": {
+                  "line": 14,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var8",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 11
+                },
+                "end": {
+                  "line": 15,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 15,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 5
+            },
+            "end": {
+              "line": 15,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "var9",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "var10",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 18
+                      }
+                    }
+                  },
+                  {
+                    "type": "OmittedExpression",
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 21
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "var11",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 27
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 28
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "var12",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 38
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 38
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 39
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 45
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 42,
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 50
+                      }
+                    }
+                  },
+                  {
+                    "type": "OmittedExpression",
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 52
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 53
+                      }
+                    }
+                  },
+                  {
+                    "type": "BinaryExpression",
+                    "operator": "+",
+                    "left": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 54
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 59
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "NumberLiteral",
+                      "value": 2,
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 62
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 63
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 63
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 64
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 42
+              },
+              "end": {
+                "line": 17,
+                "column": 65
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 65
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 66
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 10
+                },
+                "end": {
+                  "line": 18,
+                  "column": 14
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 17
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 24
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 16
+                },
+                "end": {
+                  "line": 18,
+                  "column": 24
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 8
+            },
+            "end": {
+              "line": 18,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var10",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "var3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 9
+            },
+            "end": {
+              "line": 19,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var11",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "var7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 9
+            },
+            "end": {
+              "line": 20,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 9
+            },
+            "end": {
+              "line": 21,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var13",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 11
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 23
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 24
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 24
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "var14",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 32
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "var15",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 39
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 40
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "ObjectExpression",
+                      "properties": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 44
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 46
+                        }
+                      }
+                    },
+                    {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 52
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 53
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 53
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "var16",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 58
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 63
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 63
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 5
+              },
+              "end": {
+                "line": 23,
+                "column": 64
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 68
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 69
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 72
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 76
+                      }
+                    }
+                  },
+                  {
+                    "type": "ObjectExpression",
+                    "properties": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 78
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 80
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 71
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 81
+                  }
+                }
+              },
+              {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 93
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 94
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 96
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 97
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 100
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 106
+                      }
+                    }
+                  },
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [
+                      {
+                        "type": "ReturnStatement",
+                        "argument": {
+                          "type": "NumberLiteral",
+                          "value": 12,
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 116
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 118
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 23,
+                            "column": 109
+                          },
+                          "end": {
+                            "line": 23,
+                            "column": 118
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 107
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 120
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 83
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 120
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 83
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 120
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 122
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 127
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 67
+              },
+              "end": {
+                "line": 23,
+                "column": 128
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 5
+            },
+            "end": {
+              "line": 23,
+              "column": 128
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 129
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var13",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 9
+            },
+            "end": {
+              "line": 24,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var13",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 10
+                },
+                "end": {
+                  "line": 25,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 13
+                },
+                "end": {
+                  "line": 25,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 9
+            },
+            "end": {
+              "line": 25,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 1
+            },
+            "end": {
+              "line": 26,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 9
+            },
+            "end": {
+              "line": 26,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 9
+            },
+            "end": {
+              "line": 27,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var15",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 1
+            },
+            "end": {
+              "line": 28,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "var14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 9
+            },
+            "end": {
+              "line": 28,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 1
+          },
+          "end": {
+            "line": 28,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var16",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSFunctionType",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 28
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 23
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 40
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 48
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 12
+                },
+                "end": {
+                  "line": 29,
+                  "column": 48
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 29,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "var17",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var18",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 18
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 22
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 29
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 40
+                    }
+                  }
+                },
+                {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 41
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 56
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 57
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 58
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 58
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 68
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 32
+                },
+                "end": {
+                  "line": 31,
+                  "column": 68
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 5
+              },
+              "end": {
+                "line": 31,
+                "column": 30
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 73
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 75
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 80
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 83
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 87
+                      }
+                    }
+                  },
+                  {
+                    "type": "BooleanLiteral",
+                    "value": false,
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 89
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 94
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 82
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 95
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 71
+              },
+              "end": {
+                "line": 31,
+                "column": 96
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 5
+            },
+            "end": {
+              "line": 31,
+              "column": 96
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 97
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "var20",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "OmittedExpression",
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "var21",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 42
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 43
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 50
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 58
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 58
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 23
+                },
+                "end": {
+                  "line": 32,
+                  "column": 58
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 5
+              },
+              "end": {
+                "line": 32,
+                "column": 21
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 61
+              },
+              "end": {
+                "line": 32,
+                "column": 63
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 5
+            },
+            "end": {
+              "line": 32,
+              "column": 63
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "var22",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var23",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 18
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "ObjectExpression",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "a",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "NumberLiteral",
+                            "value": 5,
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 27
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 28
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 28
+                            }
+                          }
+                        },
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "b",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 30
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 31
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 33
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 38
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 30
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 38
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 40
+                        }
+                      }
+                    },
+                    {
+                      "type": "BooleanLiteral",
+                      "value": false,
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 47
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 48
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 48
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "var24",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 50
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 55
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 58
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 64
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 58
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 66
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 70
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 77
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSParenthesizedType",
+                        "typeAnnotation": {
+                          "type": "TSUnionType",
+                          "types": [
+                            {
+                              "type": "TSTypeLiteral",
+                              "members": [],
+                              "loc": {
+                                "start": {
+                                  "line": 33,
+                                  "column": 79
+                                },
+                                "end": {
+                                  "line": 33,
+                                  "column": 81
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSBooleanKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 33,
+                                  "column": 84
+                                },
+                                "end": {
+                                  "line": 33,
+                                  "column": 91
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 79
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 91
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 78
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 92
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 78
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 95
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 69
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 58
+                },
+                "end": {
+                  "line": 33,
+                  "column": 95
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 56
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 99
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 100
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "ObjectExpression",
+                    "properties": [],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 103
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 105
+                      }
+                    }
+                  },
+                  {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 107
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 111
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 102
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 112
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 98
+              },
+              "end": {
+                "line": 33,
+                "column": 113
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 5
+            },
+            "end": {
+              "line": 33,
+              "column": 113
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 114
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "var25",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 7
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 12
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "var26",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 19
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 20
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 29
+                        }
+                      }
+                    },
+                    {
+                      "type": "ObjectExpression",
+                      "properties": [],
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 33
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 34
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 34
+                  }
+                }
+              },
+              {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "Identifier",
+                        "name": "var27",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 43
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 44
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 45
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 54
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 56
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 58
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 60
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSTupleType",
+                      "elementTypes": [
+                        {
+                          "type": "TSUnionType",
+                          "types": [
+                            {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 65
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 71
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSStringKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 74
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 80
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 81
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSTypeLiteral",
+                          "members": [],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 82
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 85
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 64
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 86
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTupleType",
+                      "elementTypes": [
+                        {
+                          "type": "TSTupleType",
+                          "elementTypes": [
+                            {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 89
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 96
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 88
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 97
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 87
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 98
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 63
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 98
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 48
+                },
+                "end": {
+                  "line": 34,
+                  "column": 98
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 5
+              },
+              "end": {
+                "line": 34,
+                "column": 46
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 103
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 104
+                      }
+                    }
+                  },
+                  {
+                    "type": "ObjectExpression",
+                    "properties": [],
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 106
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 108
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 102
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 109
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 3,
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 113
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 114
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 112
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 115
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 111
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 116
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 101
+              },
+              "end": {
+                "line": 34,
+                "column": 117
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 5
+            },
+            "end": {
+              "line": 34,
+              "column": 117
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 118
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var28",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 11
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 16
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "ObjectPattern",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "var29",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 25
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "var29",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 25
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 27
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "var30",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 37
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 37
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var29",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 47
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 54
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 60
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 47
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 62
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 63
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 64
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 64
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 66
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 72
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 67
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 73
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 40
+                },
+                "end": {
+                  "line": 35,
+                  "column": 73
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 5
+              },
+              "end": {
+                "line": 35,
+                "column": 38
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 77
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 79
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "var29",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 83
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 88
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 90
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 91
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 83
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 91
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 81
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 93
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 95
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 96
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 98
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 103
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 76
+              },
+              "end": {
+                "line": 35,
+                "column": 104
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 5
+            },
+            "end": {
+              "line": 35,
+              "column": 104
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 105
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var31",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 11
+                },
+                "end": {
+                  "line": 37,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 5
+              },
+              "end": {
+                "line": 37,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 5
+            },
+            "end": {
+              "line": 37,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var32",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 11
+                },
+                "end": {
+                  "line": 38,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 5
+              },
+              "end": {
+                "line": 38,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 5
+            },
+            "end": {
+              "line": 38,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var31",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 2
+                },
+                "end": {
+                  "line": 40,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var32",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 9
+                },
+                "end": {
+                  "line": 40,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 1
+            },
+            "end": {
+              "line": 40,
+              "column": 15
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var31",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 19
+                },
+                "end": {
+                  "line": 40,
+                  "column": 24
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": true,
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 26
+                },
+                "end": {
+                  "line": 40,
+                  "column": 30
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 18
+            },
+            "end": {
+              "line": 40,
+              "column": 31
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 40,
+            "column": 31
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var31",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 2
+                },
+                "end": {
+                  "line": 41,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var31",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 9
+                },
+                "end": {
+                  "line": 41,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 1
+            },
+            "end": {
+              "line": 41,
+              "column": 15
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 19
+                },
+                "end": {
+                  "line": 41,
+                  "column": 20
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 6,
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 22
+                },
+                "end": {
+                  "line": 41,
+                  "column": 23
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 18
+            },
+            "end": {
+              "line": 41,
+              "column": 24
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 1
+          },
+          "end": {
+            "line": 41,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var31",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 2
+                },
+                "end": {
+                  "line": 42,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var32",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 9
+                },
+                "end": {
+                  "line": 42,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 1
+            },
+            "end": {
+              "line": 42,
+              "column": 15
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var31",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 19
+                },
+                "end": {
+                  "line": 42,
+                  "column": 24
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": true,
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 26
+                },
+                "end": {
+                  "line": 42,
+                  "column": 30
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 32
+                },
+                "end": {
+                  "line": 42,
+                  "column": 37
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 39
+                },
+                "end": {
+                  "line": 42,
+                  "column": 40
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 18
+            },
+            "end": {
+              "line": 42,
+              "column": 41
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 1
+          },
+          "end": {
+            "line": 42,
+            "column": 41
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 42,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var33",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 44,
+                  "column": 12
+                },
+                "end": {
+                  "line": 44,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 44,
+                "column": 5
+              },
+              "end": {
+                "line": 44,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 44,
+              "column": 5
+            },
+            "end": {
+              "line": 44,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 44,
+          "column": 1
+        },
+        "end": {
+          "line": 44,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var34",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 12
+                },
+                "end": {
+                  "line": 45,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 5
+            },
+            "end": {
+              "line": 45,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 45,
+          "column": 1
+        },
+        "end": {
+          "line": 45,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var33",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 2
+                },
+                "end": {
+                  "line": 47,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var34",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 9
+                },
+                "end": {
+                  "line": 47,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 1
+            },
+            "end": {
+              "line": 47,
+              "column": 15
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var31",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 19
+                },
+                "end": {
+                  "line": 47,
+                  "column": 24
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var32",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 26
+                },
+                "end": {
+                  "line": 47,
+                  "column": 31
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 18
+            },
+            "end": {
+              "line": 47,
+              "column": 32
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 47,
+            "column": 1
+          },
+          "end": {
+            "line": 47,
+            "column": 32
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 47,
+          "column": 1
+        },
+        "end": {
+          "line": 47,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var35",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 12
+                },
+                "end": {
+                  "line": 49,
+                  "column": 27
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 49,
+                "column": 5
+              },
+              "end": {
+                "line": 49,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 49,
+              "column": 5
+            },
+            "end": {
+              "line": 49,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 49,
+          "column": 1
+        },
+        "end": {
+          "line": 49,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "Identifier",
+                "name": "var35",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 51,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 51,
+                    "column": 7
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 51,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 51,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 2
+                },
+                "end": {
+                  "line": 51,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 51,
+              "column": 1
+            },
+            "end": {
+              "line": 51,
+              "column": 12
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 16
+                },
+                "end": {
+                  "line": 51,
+                  "column": 21
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 51,
+              "column": 15
+            },
+            "end": {
+              "line": 51,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 51,
+            "column": 1
+          },
+          "end": {
+            "line": 51,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 51,
+          "column": 1
+        },
+        "end": {
+          "line": 51,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var36",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 12
+                },
+                "end": {
+                  "line": 53,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 5
+              },
+              "end": {
+                "line": 53,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 53,
+              "column": 5
+            },
+            "end": {
+              "line": 53,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 53,
+          "column": 1
+        },
+        "end": {
+          "line": 53,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var37",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 12
+                },
+                "end": {
+                  "line": 54,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 5
+              },
+              "end": {
+                "line": 54,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 5
+            },
+            "end": {
+              "line": 54,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 54,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var38",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 12
+                },
+                "end": {
+                  "line": 55,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 55,
+                "column": 5
+              },
+              "end": {
+                "line": 55,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 55,
+              "column": 5
+            },
+            "end": {
+              "line": 55,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 55,
+          "column": 1
+        },
+        "end": {
+          "line": 55,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "Identifier",
+                "name": "var36",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 56,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 56,
+                    "column": 7
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 56,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 56,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 2
+                },
+                "end": {
+                  "line": 56,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "Identifier",
+                "name": "var37",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 56,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 56,
+                    "column": 18
+                  }
+                }
+              },
+              "right": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 56,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 56,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 13
+                },
+                "end": {
+                  "line": 56,
+                  "column": 26
+                }
+              }
+            },
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "Identifier",
+                "name": "var38",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 56,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 56,
+                    "column": 33
+                  }
+                }
+              },
+              "right": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 56,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 56,
+                    "column": 40
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 28
+                },
+                "end": {
+                  "line": 56,
+                  "column": 40
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 1
+            },
+            "end": {
+              "line": 56,
+              "column": 41
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 44
+            },
+            "end": {
+              "line": 56,
+              "column": 46
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 56,
+            "column": 1
+          },
+          "end": {
+            "line": 56,
+            "column": 46
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 56,
+          "column": 1
+        },
+        "end": {
+          "line": 56,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var39",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 5
+              },
+              "end": {
+                "line": 58,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 13
+              },
+              "end": {
+                "line": 58,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 5
+            },
+            "end": {
+              "line": 58,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 58,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var40",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 59,
+                "column": 5
+              },
+              "end": {
+                "line": 59,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "var33",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 59,
+                "column": 13
+              },
+              "end": {
+                "line": 59,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 5
+            },
+            "end": {
+              "line": 59,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 59,
+          "column": 1
+        },
+        "end": {
+          "line": 59,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var41",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 60,
+                "column": 5
+              },
+              "end": {
+                "line": 60,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "var37",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 60,
+                "column": 13
+              },
+              "end": {
+                "line": 60,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 5
+            },
+            "end": {
+              "line": 60,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 60,
+          "column": 1
+        },
+        "end": {
+          "line": 60,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var42",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 61,
+                "column": 5
+              },
+              "end": {
+                "line": 61,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 61,
+                "column": 13
+              },
+              "end": {
+                "line": 61,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 61,
+              "column": 5
+            },
+            "end": {
+              "line": 61,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 61,
+          "column": 1
+        },
+        "end": {
+          "line": 61,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var39",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 2
+                },
+                "end": {
+                  "line": 62,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "Identifier",
+                  "name": "var40",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "var41",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 9
+                },
+                "end": {
+                  "line": 62,
+                  "column": 33
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var42",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 62,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 62,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 35
+                },
+                "end": {
+                  "line": 62,
+                  "column": 43
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 62,
+              "column": 1
+            },
+            "end": {
+              "line": 62,
+              "column": 44
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [],
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 48
+                },
+                "end": {
+                  "line": 62,
+                  "column": 50
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 42,
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 53
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 55
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 57
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 58
+                    }
+                  }
+                },
+                {
+                  "type": "BinaryExpression",
+                  "operator": "+",
+                  "left": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 59
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 64
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 68
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 59
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 68
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 52
+                },
+                "end": {
+                  "line": 62,
+                  "column": 69
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 62,
+              "column": 47
+            },
+            "end": {
+              "line": 62,
+              "column": 70
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 62,
+            "column": 1
+          },
+          "end": {
+            "line": 62,
+            "column": 70
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 62,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 71
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var39",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 2
+                },
+                "end": {
+                  "line": 63,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "Identifier",
+                  "name": "var40",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "var41",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 63,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 63,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 63,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 63,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 9
+                },
+                "end": {
+                  "line": 63,
+                  "column": 33
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var42",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 63,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 63,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 35
+                },
+                "end": {
+                  "line": 63,
+                  "column": 43
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 1
+            },
+            "end": {
+              "line": 63,
+              "column": 44
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 48
+                },
+                "end": {
+                  "line": 63,
+                  "column": 50
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 42,
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 53
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 55
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 57
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 58
+                    }
+                  }
+                },
+                {
+                  "type": "BinaryExpression",
+                  "operator": "+",
+                  "left": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 63,
+                        "column": 59
+                      },
+                      "end": {
+                        "line": 63,
+                        "column": 64
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 63,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 63,
+                        "column": 68
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 59
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 68
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 52
+                },
+                "end": {
+                  "line": 63,
+                  "column": 69
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 3,
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 71
+                },
+                "end": {
+                  "line": 63,
+                  "column": 72
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 74
+                },
+                "end": {
+                  "line": 63,
+                  "column": 79
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 81
+                },
+                "end": {
+                  "line": 63,
+                  "column": 86
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 47
+            },
+            "end": {
+              "line": 63,
+              "column": 87
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 63,
+            "column": 1
+          },
+          "end": {
+            "line": 63,
+            "column": 87
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 63,
+          "column": 1
+        },
+        "end": {
+          "line": 63,
+          "column": 88
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var39",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 2
+                },
+                "end": {
+                  "line": 65,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "var40",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "OmittedExpression",
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 18
+                      }
+                    }
+                  },
+                  {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "var41",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 65,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 65,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 65,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 65,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 32
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 65,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 65,
+                    "column": 33
+                  }
+                }
+              },
+              "right": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 45,
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 39
+                      }
+                    }
+                  },
+                  {
+                    "type": "OmittedExpression",
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 42
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 48
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 65,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 65,
+                    "column": 49
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 9
+                },
+                "end": {
+                  "line": 65,
+                  "column": 49
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var42",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 65,
+                    "column": 54
+                  },
+                  "end": {
+                    "line": 65,
+                    "column": 59
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 51
+                },
+                "end": {
+                  "line": 65,
+                  "column": 59
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 65,
+              "column": 1
+            },
+            "end": {
+              "line": 65,
+              "column": 60
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [],
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 64
+                },
+                "end": {
+                  "line": 65,
+                  "column": 66
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 42,
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 69
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 71
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 73
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 74
+                    }
+                  }
+                },
+                {
+                  "type": "BinaryExpression",
+                  "operator": "+",
+                  "left": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 75
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 80
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 65,
+                        "column": 83
+                      },
+                      "end": {
+                        "line": 65,
+                        "column": 84
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 75
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 84
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 68
+                },
+                "end": {
+                  "line": 65,
+                  "column": 85
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 65,
+              "column": 63
+            },
+            "end": {
+              "line": 65,
+              "column": 86
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 65,
+            "column": 1
+          },
+          "end": {
+            "line": 65,
+            "column": 86
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 65,
+          "column": 1
+        },
+        "end": {
+          "line": 65,
+          "column": 87
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var43",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 67,
+                "column": 5
+              },
+              "end": {
+                "line": 67,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 45,
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 13
+                },
+                "end": {
+                  "line": 67,
+                  "column": 26
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 67,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 67,
+                    "column": 35
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 30
+                },
+                "end": {
+                  "line": 67,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 67,
+                "column": 13
+              },
+              "end": {
+                "line": 67,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 67,
+              "column": 5
+            },
+            "end": {
+              "line": 67,
+              "column": 36
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 67,
+          "column": 1
+        },
+        "end": {
+          "line": 67,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var44",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 5
+              },
+              "end": {
+                "line": 69,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 13
+              },
+              "end": {
+                "line": 69,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 69,
+              "column": 5
+            },
+            "end": {
+              "line": 69,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 69,
+          "column": 1
+        },
+        "end": {
+          "line": 69,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var39",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 71,
+                  "column": 2
+                },
+                "end": {
+                  "line": 71,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "var40",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 71,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 71,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "OmittedExpression",
+                    "loc": {
+                      "start": {
+                        "line": 71,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 71,
+                        "column": 18
+                      }
+                    }
+                  },
+                  {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "var41",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 71,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 71,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 71,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 71,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 71,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 71,
+                        "column": 32
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 71,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 71,
+                    "column": 33
+                  }
+                }
+              },
+              "right": {
+                "type": "Identifier",
+                "name": "var43",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 71,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 71,
+                    "column": 41
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 71,
+                  "column": 9
+                },
+                "end": {
+                  "line": 71,
+                  "column": 41
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var42",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 71,
+                    "column": 46
+                  },
+                  "end": {
+                    "line": 71,
+                    "column": 51
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 71,
+                  "column": 43
+                },
+                "end": {
+                  "line": 71,
+                  "column": 51
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 71,
+              "column": 1
+            },
+            "end": {
+              "line": 71,
+              "column": 52
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [],
+              "loc": {
+                "start": {
+                  "line": 71,
+                  "column": 56
+                },
+                "end": {
+                  "line": 71,
+                  "column": 58
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 42,
+                  "loc": {
+                    "start": {
+                      "line": 71,
+                      "column": 61
+                    },
+                    "end": {
+                      "line": 71,
+                      "column": 63
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 71,
+                      "column": 65
+                    },
+                    "end": {
+                      "line": 71,
+                      "column": 66
+                    }
+                  }
+                },
+                {
+                  "type": "BinaryExpression",
+                  "operator": "+",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "var44",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 71,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 71,
+                        "column": 72
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 71,
+                        "column": 75
+                      },
+                      "end": {
+                        "line": 71,
+                        "column": 76
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 71,
+                      "column": 67
+                    },
+                    "end": {
+                      "line": 71,
+                      "column": 76
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 71,
+                  "column": 60
+                },
+                "end": {
+                  "line": 71,
+                  "column": 77
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 71,
+              "column": 55
+            },
+            "end": {
+              "line": 71,
+              "column": 78
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 71,
+            "column": 1
+          },
+          "end": {
+            "line": 71,
+            "column": 78
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 71,
+          "column": 1
+        },
+        "end": {
+          "line": 71,
+          "column": 79
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var45",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 12
+                },
+                "end": {
+                  "line": 73,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 73,
+                "column": 5
+              },
+              "end": {
+                "line": 73,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 73,
+              "column": 5
+            },
+            "end": {
+              "line": 73,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 73,
+          "column": 1
+        },
+        "end": {
+          "line": 73,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var46",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 74,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 74,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 74,
+                  "column": 12
+                },
+                "end": {
+                  "line": 74,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 74,
+                "column": 5
+              },
+              "end": {
+                "line": 74,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 74,
+              "column": 5
+            },
+            "end": {
+              "line": 74,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 74,
+          "column": 1
+        },
+        "end": {
+          "line": 74,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var47",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSParenthesizedType",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 75,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 75,
+                          "column": 19
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 75,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 75,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 75,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 75,
+                      "column": 28
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 75,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 75,
+                    "column": 29
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 75,
+                  "column": 12
+                },
+                "end": {
+                  "line": 75,
+                  "column": 31
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 75,
+                "column": 5
+              },
+              "end": {
+                "line": 75,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 75,
+              "column": 5
+            },
+            "end": {
+              "line": 75,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 75,
+          "column": 1
+        },
+        "end": {
+          "line": 75,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var48",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 76,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 76,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 76,
+                  "column": 12
+                },
+                "end": {
+                  "line": 76,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 76,
+                "column": 5
+              },
+              "end": {
+                "line": 76,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 76,
+              "column": 5
+            },
+            "end": {
+              "line": 76,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 76,
+          "column": 1
+        },
+        "end": {
+          "line": 76,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "var45",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 2
+                },
+                "end": {
+                  "line": 78,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var46",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 9
+                },
+                "end": {
+                  "line": 78,
+                  "column": 14
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var47",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 16
+                },
+                "end": {
+                  "line": 78,
+                  "column": 21
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var47",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 23
+                },
+                "end": {
+                  "line": 78,
+                  "column": 28
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "var47",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 30
+                },
+                "end": {
+                  "line": 78,
+                  "column": 35
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var48",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 78,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 78,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 37
+                },
+                "end": {
+                  "line": 78,
+                  "column": 45
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 78,
+              "column": 1
+            },
+            "end": {
+              "line": 78,
+              "column": 46
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 51
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 56
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 58
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 63
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 50
+                },
+                "end": {
+                  "line": 78,
+                  "column": 64
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 67
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 68
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 70
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 71
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 66
+                },
+                "end": {
+                  "line": 78,
+                  "column": 72
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 75
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 80
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 82
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 87
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 74
+                },
+                "end": {
+                  "line": 78,
+                  "column": 88
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 91
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 92
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 94
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 90
+                },
+                "end": {
+                  "line": 78,
+                  "column": 96
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 99
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 100
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 102
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 107
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 98
+                },
+                "end": {
+                  "line": 78,
+                  "column": 108
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 110
+                },
+                "end": {
+                  "line": 78,
+                  "column": 115
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 117
+                },
+                "end": {
+                  "line": 78,
+                  "column": 122
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 78,
+              "column": 49
+            },
+            "end": {
+              "line": 78,
+              "column": 123
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 78,
+            "column": 1
+          },
+          "end": {
+            "line": 78,
+            "column": 123
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 78,
+          "column": 1
+        },
+        "end": {
+          "line": 78,
+          "column": 123
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var49",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 80,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 80,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 80,
+                  "column": 12
+                },
+                "end": {
+                  "line": 80,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 80,
+                "column": 5
+              },
+              "end": {
+                "line": 80,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 80,
+              "column": 5
+            },
+            "end": {
+              "line": 80,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 80,
+          "column": 1
+        },
+        "end": {
+          "line": 80,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var50",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 81,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 81,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 81,
+                  "column": 12
+                },
+                "end": {
+                  "line": 81,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 81,
+                "column": 5
+              },
+              "end": {
+                "line": 81,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 81,
+              "column": 5
+            },
+            "end": {
+              "line": 81,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 81,
+          "column": 1
+        },
+        "end": {
+          "line": 81,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "RestElement",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "var49",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 82,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 82,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 82,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 82,
+                      "column": 11
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 2
+                },
+                "end": {
+                  "line": 82,
+                  "column": 12
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var50",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 82,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 82,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 14
+                },
+                "end": {
+                  "line": 82,
+                  "column": 22
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 82,
+              "column": 1
+            },
+            "end": {
+              "line": 82,
+              "column": 23
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 82,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 82,
+                      "column": 33
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 82,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 82,
+                      "column": 40
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 27
+                },
+                "end": {
+                  "line": 82,
+                  "column": 41
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 43
+                },
+                "end": {
+                  "line": 82,
+                  "column": 44
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 46
+                },
+                "end": {
+                  "line": 82,
+                  "column": 47
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 82,
+              "column": 26
+            },
+            "end": {
+              "line": 82,
+              "column": 48
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 82,
+            "column": 1
+          },
+          "end": {
+            "line": 82,
+            "column": 48
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 82,
+          "column": 1
+        },
+        "end": {
+          "line": 82,
+          "column": 48
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 82,
+      "column": 48
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/arrayDestructuring.ts b/es2panda/test/compiler/ts/arrayDestructuring.ts
new file mode 100644
index 0000000000000000000000000000000000000000..80c5a510c9ed583b6fd13d2ce33f9d352f128ef9
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring.ts
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [var1, var2] = [1, "foo", true];
+var1 = 2;
+var2 = "bar";
+
+var var3: number;
+var var4: boolean;
+var [var3, , var4] = [var1, , true];
+
+var [var5 = 2] = ["foo"];
+var var5: number | string;
+
+var [var6 = 1, var7 = "asd", var8 = true] = [];
+var var6: number;
+var var7: string;
+var var8: boolean;
+
+var [var9, [var10, , var11], ...var12] = [{}, [42, , "foo" + 2]];
+var9 = { a: 5, b: "foo" };
+var10 = var3;
+var11 = var7;
+var12 = [];
+
+var [var13 = [1, "foo"], [var14, var15] = [{}, true], ...var16] = [3, [true, {}], function (a, b): number { return 12 }, "bar"];
+var13 = 5;
+var13 = [2, "baz"];
+var14 = {};
+var14 = false;
+var15 = var14;
+var var16: [(a: any, b: any) => number, string];
+
+var [var17, var18 = 6, var19]: [number, number | string, boolean[]] = [1, "foo", [true, false]];
+var [var20, , var21]: number[] | [number, number, string] = [];
+var [var22, var23 = [{ a: 5, b: "foo" }, false], var24]: string[] | [number, ({} | boolean)[]] = [1, [{}, true]];
+var [[var25, var26] = ["foo", {}], [[var27]]]: number[][][] | [[number | string, {}], [[number]]] = [[1, {}], [[3]]];
+var [var28 = {}, { var29 }, ...var30]: [{}, { var29: number }, 1, "foo"] = [{}, { var29: 5 }, 1, "foo"];
+
+var var31:number;
+var var32:boolean;
+
+[var31, var32] = [var31, true];
+[var31, var31] = [5, 6];
+[var31, var32] = [var31, true, false, 5];
+
+var var33: number;
+var var34: boolean;
+
+[var33, var34] = [var31, var32];
+
+var var35: string | number;
+
+[var35 = 2] = ["foo"];
+
+var var36: number;
+var var37: string;
+var var38: boolean;
+[var36 = 1, var37 = "asd", var38 = true] = [];
+
+var var39 = {};
+var var40 = var33;
+var var41 = var37;
+var var42 = [];
+[var39, [var40, , var41 = "bar"], ...var42] = [{}, [42, , "foo" + 2]];
+[var39, [var40, , var41 = "bar"], ...var42] = [{}, [42, , "foo" + 2], 3, "baz", false];
+
+[var39, [var40, , var41 = "bar"] = [45, , "baz"], ...var42] = [{}, [42, , "foo" + 2]];
+
+var var43 = [45, , "baz"] as const;
+
+var var44 = "foo";
+
+[var39, [var40, , var41 = "bar"] = var43, ...var42] = [{}, [42, , var44 + 2]];
+
+var var45: string[];
+var var46: number[];
+var var47: (string | number)[];
+var var48: string[];
+
+[var45, var46, var47, var47, var47, ...var48] = [["foo", "bar"], [1, 2], ["foo", "bar"], [1, 2], [1, "foo"], "bar", "bar"]
+
+var var49: string[];
+var var50: number[];
+[[...var49], ...var50] = [["foo", "bar"], 1, 2]
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring1-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f6074d42dc5110e5f2a26d8f524ddd81a07f857c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring1-expected.txt
@@ -0,0 +1,89 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 11
+              },
+              "end": {
+                "line": 1,
+                "column": 13
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 14
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring1.ts:1:6]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring1.ts b/es2panda/test/compiler/ts/arrayDestructuring1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aed985a1757520cdbf7e1ef9f02158f472d404f1
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a] = [];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring10-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..003fc94e0e89ac736f596b9ccf185c51c29aa3df
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring10-expected.txt
@@ -0,0 +1,271 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 21
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "OmittedExpression",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 32
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 38
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 42
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 24
+              },
+              "end": {
+                "line": 1,
+                "column": 43
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 43
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type '[boolean, { }]'. [arrayDestructuring10.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring10.ts b/es2panda/test/compiler/ts/arrayDestructuring10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e0c3f4c09d5cf258ed7a70e201fc830436a357d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring10.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = 6, b, ...c] = [, "foo", true, {}];
+c = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring11-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f7aa0d177fe39a0491e30e63891b6d3493efab60
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring11-expected.txt
@@ -0,0 +1,201 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 10
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 30
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 30
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type '(number | string | boolean)[]'. [arrayDestructuring11.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring11.ts b/es2panda/test/compiler/ts/arrayDestructuring11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6be3feeb40b5c6e0e6f05380a014781d218c97cc
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring11.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [...a] = [1, "foo", true];
+a = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring12-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..520d543bb756519752c56a0fcdc5d2aef4c93f66
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring12-expected.txt
@@ -0,0 +1,295 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 29
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 36
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSBooleanKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 45
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 56
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 59
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 60
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 59
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 60
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 20
+                },
+                "end": {
+                  "line": 1,
+                  "column": 60
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 18
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 64
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 69
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 71
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 76
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 63
+              },
+              "end": {
+                "line": 1,
+                "column": 77
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 77
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 78
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 78
+    }
+  }
+}
+TypeError: Type '[number, string, boolean] | string[] | 5' must have a '[Symbol.iterator]()' method that returns an interator [arrayDestructuring12.ts:1:6]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring12.ts b/es2panda/test/compiler/ts/arrayDestructuring12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0e9e388a9f0365f471007464fdf58bb37a9b8514
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring12.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = 5, ...b]: [number, string, boolean] | string[] | 5 = ["foo", "bar"];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring13-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4ace32cef81e33ce60f70a3036db00cef8960030
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring13-expected.txt
@@ -0,0 +1,260 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 14
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'number'. [arrayDestructuring13.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring13.ts b/es2panda/test/compiler/ts/arrayDestructuring13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..76b39379f57287e3def7ad41e5d00e211c0baae9
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring13.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string, number];
+var [b, c] = a;
+b = {}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring14-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f0f16ae1fe9ac3e2148d9ffe6440f23752933260
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring14-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 14
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 18
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 22
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 24
+    }
+  }
+}
+TypeError: Type 'number' must have a '[Symbol.iterator]()' method that returns an interator [arrayDestructuring14.ts:2:5]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring14.ts b/es2panda/test/compiler/ts/arrayDestructuring14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..41cca42fb5637bd8fd467151ffa3b4ccf26e7364
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring14.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var [b = 6, c = 6] = a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring15-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a18a57ccb96cb49d583ebfa194a1da4bd2280a1
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring15-expected.txt
@@ -0,0 +1,178 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 14
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 16
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring15.ts:2:9]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring15.ts b/es2panda/test/compiler/ts/arrayDestructuring15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5b902661e9df559e30968861406216d8628169a6
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring15.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number];
+var [b, c] = a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring16-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b76069037fc1ccdf80781c88d3be7857eb1aafc3
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring16-expected.txt
@@ -0,0 +1,261 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 10
+                    }
+                  }
+                },
+                "right": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 18
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 22
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'string'. [arrayDestructuring16.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring16.ts b/es2panda/test/compiler/ts/arrayDestructuring16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9d414e44a1c1fcc8eb6e82a1f2882c03a496b93c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring16.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [string];
+var [b, c = "foo"] = a;
+c = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring17-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..272ed00659b0b77d6e0a717c97d09cc40cbc159d
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring17-expected.txt
@@ -0,0 +1,378 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 15
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 12
+              },
+              "end": {
+                "line": 1,
+                "column": 13
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 26
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 23
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 36
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 44
+                },
+                "end": {
+                  "line": 1,
+                  "column": 51
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 35
+            },
+            "end": {
+              "line": 1,
+              "column": 51
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 14
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 23
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 52
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 14
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 17
+                },
+                "end": {
+                  "line": 5,
+                  "column": 18
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 27
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 17
+              },
+              "end": {
+                "line": 5,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 29
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 29
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring17.ts:5:12]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring17.ts b/es2panda/test/compiler/ts/arrayDestructuring17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dc3a9fae33f4c7adf7bcfea7195b9c98d125c3b8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring17.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function a(a: number, b: string): [number, string] {
+    return [1, "foo"];
+}
+
+var [b, c, d] = a(1, "bar");
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring18-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f603308a8045cdb0e44998a7e979794cbee68dba
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring18-expected.txt
@@ -0,0 +1,324 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 10
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 21
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSBigIntKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 52
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSVoidKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 53
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 58
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTypeLiteral",
+                      "members": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 62
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 13
+                },
+                "end": {
+                  "line": 1,
+                  "column": 62
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 66
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 70
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 77
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 65
+              },
+              "end": {
+                "line": 1,
+                "column": 78
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 78
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 79
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type '(number | string | boolean | bigint | void | { })[]'. [arrayDestructuring18.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring18.ts b/es2panda/test/compiler/ts/arrayDestructuring18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d3f2dc59cc149c811e86993aa3d0fbd31b7c776e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring18.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [...a]: [number, string] | boolean[] | [bigint, void, {}] = [true, false];
+a = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring19-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a2a17aed78cc4abe942879af36baa20cec5f6e7c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring19-expected.txt
@@ -0,0 +1,339 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 24
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSBigIntKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 55
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSVoidKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 56
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 61
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTypeLiteral",
+                      "members": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 62
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 65
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 65
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 16
+                },
+                "end": {
+                  "line": 1,
+                  "column": 65
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 14
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 69
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 73
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 75
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 80
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 68
+              },
+              "end": {
+                "line": 1,
+                "column": 81
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 81
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 82
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type '(string | boolean | void | { })[]'. [arrayDestructuring19.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring19.ts b/es2panda/test/compiler/ts/arrayDestructuring19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a63bdd4f2549c48e1c1b62528742f9aa9955c2a6
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring19.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, ...b]: [number, string] | boolean[] | [bigint, void, {}] = [true, false];
+b = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring2-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4c77d8e01f70bfedecf7b4a24f61c97f8e38ff7
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring2-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 12
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 17
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 17
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 10
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'number'. [arrayDestructuring2.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring2.ts b/es2panda/test/compiler/ts/arrayDestructuring2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f39442efd8fa9379c737ad280f3068fda7d707a7
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring2.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = 1] = [];
+a = "foo"
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring20-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb7b2425ba9f4b74055e06867fc284ff4b207c6f
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring20-expected.txt
@@ -0,0 +1,163 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 14
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 21
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 19
+              },
+              "end": {
+                "line": 1,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 26
+    }
+  }
+}
+TypeError: Type 'number' must have a '[Symbol.iterator]()' method that returns an interator [arrayDestructuring20.ts:1:9]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring20.ts b/es2panda/test/compiler/ts/arrayDestructuring20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..408abbf482714e9adb9ef7142ab857abd55455a2
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring20.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, [b, c]] = [1, 2];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring21-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring21-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f4963ceda493ce9d3e41e8e74ac08c0c60fb319
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring21-expected.txt
@@ -0,0 +1,149 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 8
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 12
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 13
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 16
+              },
+              "end": {
+                "line": 1,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 21
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 22
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring21.ts:1:10]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring21.ts b/es2panda/test/compiler/ts/arrayDestructuring21.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49a5a2b77ddad203a2dd3a1c515658a5adb37d39
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring21.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [[a, b]] = [[1]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring22-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring22-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e8c4c06a4e096bd82aec0f6472ef05021c21dd46
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring22-expected.txt
@@ -0,0 +1,234 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 11
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "NumberLiteral",
+                      "value": 2,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 23
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 25
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 30
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 38
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 39
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 28
+              },
+              "end": {
+                "line": 1,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 41
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 41
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type 'number', but here has type 'number | string'. [arrayDestructuring22.ts:1:10]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring22.ts b/es2panda/test/compiler/ts/arrayDestructuring22.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ebf58b8fa4b0854b544528abd2122aabf63fc2ff
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring22.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, [a, b] = [1, 2]] = [1, ["foo"]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring23-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring23-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..48af5209e6f9471197494c73518474bdf24f2cd8
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring23-expected.txt
@@ -0,0 +1,220 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 11
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 20
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 36
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 37
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 37
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 38
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 38
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring23.ts:1:13]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring23.ts b/es2panda/test/compiler/ts/arrayDestructuring23.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5734a9d0097d18ec4d9c82c481a4a7b2c36431a0
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring23.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, [b, c] = [1]] = [1, ["foo"]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring24-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring24-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..77859c8c3d41f4d1922740ba17f8b259e802d596
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring24-expected.txt
@@ -0,0 +1,398 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 11
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 23
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 31
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 32
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 45
+                      }
+                    }
+                  },
+                  {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 49
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 50
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 52
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 57
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 57
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 59
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 60
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 35
+              },
+              "end": {
+                "line": 1,
+                "column": 61
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 61
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 8
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 11
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 7
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 13
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [arrayDestructuring24.ts:2:7]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring24.ts b/es2panda/test/compiler/ts/arrayDestructuring24.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f566b082b4e0b251bd484daaf5a44eb7bd40d69e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring24.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, [b, c] = [true, "foo"]] = [1, ["foo", { a: "foo" }]];
+c = { a: 5 }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring25-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring25-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65d90c4f02eedaef0e726d548694fe822dd57172
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring25-expected.txt
@@ -0,0 +1,176 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 14
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 18
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 19
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 24
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 22
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 29
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 29
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring25.ts:1:16]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring25.ts b/es2panda/test/compiler/ts/arrayDestructuring25.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8969ace7857a276ced0a95fac63d93162d9ef0c0
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring25.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, ...[b, c]] = [1, 2];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring26-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring26-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1382a1042a8c4a86cfe9e3ca621fb64b65b1f112
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring26-expected.txt
@@ -0,0 +1,300 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "ObjectPattern",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "OmittedExpression",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 31
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 34
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 34
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 36
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 37
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 37
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 37
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 37
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring26.ts:1:18]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring26.ts b/es2panda/test/compiler/ts/arrayDestructuring26.ts
new file mode 100644
index 0000000000000000000000000000000000000000..66b0fae39f0e73be668f8564378cc60da1ce4765
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring26.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = 5, { b, c }] = [, { b: 5 }]
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring27-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring27-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0ff199e2f8473aff68a934ddccd56e51794cf073
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring27-expected.txt
@@ -0,0 +1,299 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "AssignmentPattern",
+                      "left": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "NumberLiteral",
+                        "value": 6,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "AssignmentPattern",
+                      "left": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 26
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "d",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 30
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 30
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 48
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 57
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 58
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 33
+                },
+                "end": {
+                  "line": 1,
+                  "column": 58
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 31
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 62
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 63
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 65
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 66
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 61
+              },
+              "end": {
+                "line": 1,
+                "column": 67
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 67
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 68
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 68
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring27.ts:1:28]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring27.ts b/es2panda/test/compiler/ts/arrayDestructuring27.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d1d6d73e8bce294b26b441e06a28003d5f6a3cbd
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring27.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [...[b = 6, c = "foo", d]]: [number, number | string] = [1, 2];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring28-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring28-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2c340ac0aa840ec2868b30bb94dffd9d6a82af12
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring28-expected.txt
@@ -0,0 +1,502 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "b",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 6,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 16
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 17
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 17
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 17
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 20
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "foo",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 22
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 25
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 27
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "d",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 30
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 31
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "NumberLiteral",
+                          "value": 6,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 34
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 35
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "e",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 39
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 40
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 41
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 46
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 51
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 52
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "NumberLiteral",
+                          "value": 2,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 54
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 55
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 51
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 55
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 49
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 57
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 60
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 61
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 63
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 68
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 59
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 69
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 70
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 44
+              },
+              "end": {
+                "line": 1,
+                "column": 71
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 71
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 72
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'string'. [arrayDestructuring28.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring28.ts b/es2panda/test/compiler/ts/arrayDestructuring28.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ecdf8d0eb1931c05272a7badfac798bd39bf320e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring28.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, [{ b = 6, c: foo }, [d = 6, e]]] = [1, [{ c: 2 }, [1, "foo"]]];
+e = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring29-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring29-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..46d3ed959ab2322df676715b2b65ab5870725b64
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring29-expected.txt
@@ -0,0 +1,145 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 7
+                },
+                "end": {
+                  "line": 1,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 2
+                },
+                "end": {
+                  "line": 2,
+                  "column": 3
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 7
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 10
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring29.ts:2:2]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring29.ts b/es2panda/test/compiler/ts/arrayDestructuring29.ts
new file mode 100644
index 0000000000000000000000000000000000000000..83f3475c3142ae92c19841c68be1c23efee1f80f
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring29.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a:number;
+[a] = [];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring3-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cf136aab073a239ac05a3c1447dcb77c17e39e33
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring3-expected.txt
@@ -0,0 +1,187 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 12
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'number | string'. [arrayDestructuring3.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring3.ts b/es2panda/test/compiler/ts/arrayDestructuring3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..509a576070a416af6fc1b3c7efe3edce1338082a
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring3.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = 1] = ["foo"];
+a = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring30-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring30-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..402b8a0c010c11dd6635379575a300401f8fd6c9
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring30-expected.txt
@@ -0,0 +1,245 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 7
+                },
+                "end": {
+                  "line": 1,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 3
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 7
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 17
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring30.ts:3:9]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring30.ts b/es2panda/test/compiler/ts/arrayDestructuring30.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e77114f602489cb486eac9e586261a8a5d11cbca
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring30.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a:number;
+var b: number;
+[a = 5, b] = [];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring31-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring31-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e0e74494e12a4a20abd07b20211eabe408c82963
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring31-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 7
+                },
+                "end": {
+                  "line": 1,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 3
+                  }
+                }
+              },
+              "right": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 2
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 12
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 15
+            },
+            "end": {
+              "line": 2,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 18
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 18
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'number'. [arrayDestructuring31.ts:2:2]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring31.ts b/es2panda/test/compiler/ts/arrayDestructuring31.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3cf650c0cea88c4e76ec92c85af626e35366a17c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring31.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a:number;
+[a = "foo"] = [];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring32-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring32-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53c4a24a15d63027fb93ab22bc7b5563bada7072
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring32-expected.txt
@@ -0,0 +1,87 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 2
+                },
+                "end": {
+                  "line": 1,
+                  "column": 3
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 7
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 10
+    }
+  }
+}
+TypeError: Cannot find name 'a'. [arrayDestructuring32.ts:1:2]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring32.ts b/es2panda/test/compiler/ts/arrayDestructuring32.ts
new file mode 100644
index 0000000000000000000000000000000000000000..26e83a562be82adb47ee7c1ba8768fd2fc1a15a5
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring32.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+[a] = [];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring33-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring33-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b52eb582b0a6c9ee9181dd937de73bc4f18c9519
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring33-expected.txt
@@ -0,0 +1,160 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 2
+                },
+                "end": {
+                  "line": 2,
+                  "column": 3
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 7
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 15
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [arrayDestructuring33.ts:2:2]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring33.ts b/es2panda/test/compiler/ts/arrayDestructuring33.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b4907fc208756c99b700589f38f79743d9eee5de
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring33.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+[a] = ["foo"];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring34-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring34-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..93243271d9a17b2576cdb5eb52eb811da8283785
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring34-expected.txt
@@ -0,0 +1,204 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 3
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 7
+            },
+            "end": {
+              "line": 3,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 9
+    }
+  }
+}
+TypeError: Type 'number' must have a '[Symbol.iterator]()' method that returns an interator [arrayDestructuring34.ts:3:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring34.ts b/es2panda/test/compiler/ts/arrayDestructuring34.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b59bc5867c6a60abf99e9e3f14dff91c4e033ab
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring34.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var b = 5;
+[a] = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring35-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring35-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b9f17f884899a86a11c5b5337577cc3be8725727
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring35-expected.txt
@@ -0,0 +1,215 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 23
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 3
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 7
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 7
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 12
+                },
+                "end": {
+                  "line": 3,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 11
+            },
+            "end": {
+              "line": 3,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 19
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string | number'. [arrayDestructuring35.ts:3:2]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring35.ts b/es2panda/test/compiler/ts/arrayDestructuring35.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bed9093bee3a41565451ab53f5b1837bef665972
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring35.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string | number;
+
+[a = 2] = [false];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring36-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring36-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..878de3251a1e641526d9cc5d72c403005f247248
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring36-expected.txt
@@ -0,0 +1,687 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 7
+                },
+                "end": {
+                  "line": 3,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 9
+              },
+              "end": {
+                "line": 4,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 18
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 9
+                },
+                "end": {
+                  "line": 5,
+                  "column": 19
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 28
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 23
+                },
+                "end": {
+                  "line": 5,
+                  "column": 28
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 9
+              },
+              "end": {
+                "line": 5,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 2
+                },
+                "end": {
+                  "line": 6,
+                  "column": 3
+                }
+              }
+            },
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 7
+                      }
+                    }
+                  },
+                  {
+                    "type": "OmittedExpression",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 10
+                      }
+                    }
+                  },
+                  {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 12
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 20
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 21
+                  }
+                }
+              },
+              "right": {
+                "type": "Identifier",
+                "name": "e",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 25
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 25
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 31
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 27
+                },
+                "end": {
+                  "line": 6,
+                  "column": 31
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 32
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 36
+                },
+                "end": {
+                  "line": 6,
+                  "column": 38
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 42,
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 43
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "BinaryExpression",
+                  "operator": "+",
+                  "left": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 55
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 56
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 56
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 40
+                },
+                "end": {
+                  "line": 6,
+                  "column": 57
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 35
+            },
+            "end": {
+              "line": 6,
+              "column": 58
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 58
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 59
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 59
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'number'. [arrayDestructuring36.ts:6:6]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring36.ts b/es2panda/test/compiler/ts/arrayDestructuring36.ts
new file mode 100644
index 0000000000000000000000000000000000000000..52557f7efce6d3ae4d1a7720c878a71a6f81f3d7
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring36.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {};
+var b: number;
+var c:string;
+var d = [];
+var e = ["foo", 5] as const;
+[a, [b, , c = "bar"] = e, ...d] = [{}, [42, , "foo" + 2]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring37-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring37-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..58329f5498c21a03639793a45484ba2bc6028532
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring37-expected.txt
@@ -0,0 +1,587 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 7
+                },
+                "end": {
+                  "line": 3,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 9
+              },
+              "end": {
+                "line": 4,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 2
+                },
+                "end": {
+                  "line": 5,
+                  "column": 3
+                }
+              }
+            },
+            {
+              "type": "AssignmentPattern",
+              "left": {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 7
+                      }
+                    }
+                  },
+                  {
+                    "type": "OmittedExpression",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 10
+                      }
+                    }
+                  },
+                  {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 12
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 20
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 21
+                  }
+                }
+              },
+              "right": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 30
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 33
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 34
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 5
+                },
+                "end": {
+                  "line": 5,
+                  "column": 34
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 40
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 36
+                },
+                "end": {
+                  "line": 5,
+                  "column": 40
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 41
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 45
+                },
+                "end": {
+                  "line": 5,
+                  "column": 47
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 42,
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 50
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 52
+                    }
+                  }
+                },
+                {
+                  "type": "OmittedExpression",
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 54
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 55
+                    }
+                  }
+                },
+                {
+                  "type": "BinaryExpression",
+                  "operator": "+",
+                  "left": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 61
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 64
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 56
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 65
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 49
+                },
+                "end": {
+                  "line": 5,
+                  "column": 66
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 44
+            },
+            "end": {
+              "line": 5,
+              "column": 67
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 67
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 68
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 68
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [arrayDestructuring37.ts:5:6]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring37.ts b/es2panda/test/compiler/ts/arrayDestructuring37.ts
new file mode 100644
index 0000000000000000000000000000000000000000..063164a4bb54728caac0ada63fba2fda4fd8e224
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring37.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {};
+var b: number;
+var c:string;
+var d = [];
+[a, [b, , c = "bar"] = ["foo", 5], ...d] = [{}, [42, , "foo" + 2]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring38-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring38-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9b88e36186ba5e59dbfee4556ef6f3f274c8b42e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring38-expected.txt
@@ -0,0 +1,175 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 7
+                },
+                "end": {
+                  "line": 1,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 4
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 2
+                },
+                "end": {
+                  "line": 2,
+                  "column": 5
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 9
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 14
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring38.ts:2:3]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring38.ts b/es2panda/test/compiler/ts/arrayDestructuring38.ts
new file mode 100644
index 0000000000000000000000000000000000000000..50ebf9dcdb99c1f5e66878e4b1418fe634343c24
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring38.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a:number;
+[[a]] = [[]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring39-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring39-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ffc9fffa1a4b19fa69272371b1f356fddda754f2
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring39-expected.txt
@@ -0,0 +1,275 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 7
+                },
+                "end": {
+                  "line": 1,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 3
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 4
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 8
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 16
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 21
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring39.ts:3:10]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring39.ts b/es2panda/test/compiler/ts/arrayDestructuring39.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df8cabb07e3afaa36488d64d7500a9f1179fa251
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring39.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a:number;
+var b: number;
+[[a = 5, b]] = [[]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring4-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2879558ad380ab52992c5d8aa03fbfbb0544268b
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring4-expected.txt
@@ -0,0 +1,145 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 26
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 31
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 29
+              },
+              "end": {
+                "line": 1,
+                "column": 32
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 32
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 33
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 33
+    }
+  }
+}
+TypeError: Type '[number]' is not assignable to type '[number, string]'. [arrayDestructuring4.ts:1:5]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring4.ts b/es2panda/test/compiler/ts/arrayDestructuring4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cdffb20264de18916e594ed2140ed40e80aae514
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a]: [number, string] = [1];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring40-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring40-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c946d705c236d8e9757e47c67fefae538600f9ed
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring40-expected.txt
@@ -0,0 +1,190 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 4
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 2
+                },
+                "end": {
+                  "line": 2,
+                  "column": 5
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 16
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 9
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 19
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [arrayDestructuring40.ts:2:3]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring40.ts b/es2panda/test/compiler/ts/arrayDestructuring40.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1f1704937d9d19f7d21d84417567099defba466e
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring40.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+[[a]] = [["foo"]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring41-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring41-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c2063a6f29142b904510b342871f2d2932c39a93
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring41-expected.txt
@@ -0,0 +1,234 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 4
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 5
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 10
+                },
+                "end": {
+                  "line": 3,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 9
+            },
+            "end": {
+              "line": 3,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 13
+    }
+  }
+}
+TypeError: Type 'number' must have a '[Symbol.iterator]()' method that returns an interator [arrayDestructuring41.ts:3:2]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring41.ts b/es2panda/test/compiler/ts/arrayDestructuring41.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bb06934d94414dfc1e9480753792649b24700f29
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring41.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var b = 5;
+[[a]] = [b];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring42-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring42-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4e600195d6269a818e47855b47998897bc2f8026
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring42-expected.txt
@@ -0,0 +1,202 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 3
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 7
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 19
+    }
+  }
+}
+TypeError: Type '(string | number)[]' is not assignable to type 'string[]'. [arrayDestructuring42.ts:3:2]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring42.ts b/es2panda/test/compiler/ts/arrayDestructuring42.ts
new file mode 100644
index 0000000000000000000000000000000000000000..388e8f5c1869fb85ffb79662e918a971589580af
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring42.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+
+[a] = [["foo", 1]]
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring43-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring43-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..063d3db0dc7e15e239264ac4dca7593062def1ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring43-expected.txt
@@ -0,0 +1,186 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 13
+    }
+  }
+}
+TypeError: Type 'number[]' is not assignable to type 'string[]'. [arrayDestructuring43.ts:3:5]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring43.ts b/es2panda/test/compiler/ts/arrayDestructuring43.ts
new file mode 100644
index 0000000000000000000000000000000000000000..06f15b5732bff6928d45ee97c83ef75ff3d02491
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring43.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+
+[...a] = [2]
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring44-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring44-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8cfa02c7460cab095451a84721345b258c81d214
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring44-expected.txt
@@ -0,0 +1,343 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ArrayPattern",
+          "elements": [
+            {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "RestElement",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 7
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 2
+                },
+                "end": {
+                  "line": 4,
+                  "column": 8
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 10
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "BooleanLiteral",
+                  "value": false,
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 19
+                },
+                "end": {
+                  "line": 4,
+                  "column": 33
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 35
+                },
+                "end": {
+                  "line": 4,
+                  "column": 40
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 18
+            },
+            "end": {
+              "line": 4,
+              "column": 41
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 41
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 41
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 41
+    }
+  }
+}
+TypeError: Type '(string | boolean)[]' is not assignable to type 'string[]'. [arrayDestructuring44.ts:4:6]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring44.ts b/es2panda/test/compiler/ts/arrayDestructuring44.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7cec1a124d023fee5784236f605897b8bfcd4883
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring44.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+var b: string[];
+
+[[...b], ...a] = [["foo", false], "foo"]
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring5-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..735dc64d7f7a70411a1a13ee370185033bf8930c
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring5-expected.txt
@@ -0,0 +1,228 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 14
+                    }
+                  }
+                },
+                "right": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 22
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 25
+                },
+                "end": {
+                  "line": 1,
+                  "column": 41
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 23
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 46
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 49
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 44
+              },
+              "end": {
+                "line": 1,
+                "column": 50
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 50
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 51
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 51
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [arrayDestructuring5.ts:1:13]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring5.ts b/es2panda/test/compiler/ts/arrayDestructuring5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..485e2d84182e9889f7c71cdf5266c3ef1f576f85
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = 1, b = "foo"]: [number, number] = [1, 1];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring6-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..88e0bb70b80da5ca875f1251c65de0d53def159a
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring6-expected.txt
@@ -0,0 +1,271 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 40
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 40
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 13
+                },
+                "end": {
+                  "line": 1,
+                  "column": 40
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 48
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 43
+              },
+              "end": {
+                "line": 1,
+                "column": 49
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 49
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'number | string'. [arrayDestructuring6.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring6.ts b/es2panda/test/compiler/ts/arrayDestructuring6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..07b28d03d79c598f738c4dc11f7db40525917600
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, b]: number[] | [string, number] = [1, 2];
+a = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring7-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..de1907b8a13cadfcfa09899907d911fe8b0f56be
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring7-expected.txt
@@ -0,0 +1,204 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 12
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 19
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 33
+                      }
+                    }
+                  },
+                  {
+                    "type": "BooleanLiteral",
+                    "value": false,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 40
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 41
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 27
+              },
+              "end": {
+                "line": 1,
+                "column": 43
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 43
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 44
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [arrayDestructuring7.ts:1:22]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring7.ts b/es2panda/test/compiler/ts/arrayDestructuring7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9601ba69fddb33c42259938927f8ac1149f0eb48
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = [1, "foo"], b] = [[true, false],];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring8-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4c570dffae60266854d667b5230d9e94cf20936a
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring8-expected.txt
@@ -0,0 +1,303 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 7
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 12
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 19
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 33
+                      }
+                    }
+                  },
+                  {
+                    "type": "BooleanLiteral",
+                    "value": false,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 40
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 41
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 44
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 49
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 56
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 57
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 27
+              },
+              "end": {
+                "line": 1,
+                "column": 58
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 58
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 59
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type '(number | string)[] | boolean[]'. [arrayDestructuring8.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring8.ts b/es2panda/test/compiler/ts/arrayDestructuring8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..02ce4ae88bb8e045db1dd6ee204e5497ae080eac
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring8.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a = [1, "foo"], b] = [[true, false], ["foo", "bar"]];
+a = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/arrayDestructuring9-expected.txt b/es2panda/test/compiler/ts/arrayDestructuring9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d87dfae53afc1b1796c4a8ef932dd382a32ecad0
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring9-expected.txt
@@ -0,0 +1,203 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 14
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 17
+              },
+              "end": {
+                "line": 1,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 20
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 9
+    }
+  }
+}
+TypeError: Type '[number]' is not assignable to type '[]'. [arrayDestructuring9.ts:2:1]
diff --git a/es2panda/test/compiler/ts/arrayDestructuring9.ts b/es2panda/test/compiler/ts/arrayDestructuring9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb1618452de7c7c9662dcf5e545ab6164edc37b7
--- /dev/null
+++ b/es2panda/test/compiler/ts/arrayDestructuring9.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var [a, ...b] = [1];
+b = [1];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/array_1-expected.txt b/es2panda/test/compiler/ts/array_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b7e2dbe33f6f1093d7666b5f54d886bf7894c077
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_1-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [array_1.ts:2:12]
diff --git a/es2panda/test/compiler/ts/array_1.ts b/es2panda/test/compiler/ts/array_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b5ce2f7b7a74771b92eb039fbf7278e23844b5c9
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_1.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+a = ["foo",5];
diff --git a/es2panda/test/compiler/ts/array_10-expected.txt b/es2panda/test/compiler/ts/array_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..23a6c5641946e4d1ebbd0bad3e1c9f399560bac3
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_10-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'number'. [array_10.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_10.ts b/es2panda/test/compiler/ts/array_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d400130faa9f6aeeb2ea00d3a56f70ff0aa447c9
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_10.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[];
+a = [false,5];
diff --git a/es2panda/test/compiler/ts/array_11-expected.txt b/es2panda/test/compiler/ts/array_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fd58980b024f70e3905dd29533ea14c845ad46bf
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_11-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'number'. [array_11.ts:2:8]
diff --git a/es2panda/test/compiler/ts/array_11.ts b/es2panda/test/compiler/ts/array_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aebffa2a9e634d3cd005576a0bc10f66f12320b6
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_11.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[];
+a = [5,5n];
diff --git a/es2panda/test/compiler/ts/array_12-expected.txt b/es2panda/test/compiler/ts/array_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..75d5413b0ef9eb9eb042228d5d92757b2c756998
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_12-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 8
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'number'. [array_12.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_12.ts b/es2panda/test/compiler/ts/array_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3559dbdeed793d20744b2d233e824c5dc82fdcc6
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_12.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[];
+a = [5n,5];
diff --git a/es2panda/test/compiler/ts/array_13-expected.txt b/es2panda/test/compiler/ts/array_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4654cc58a08c02e1f54832511953fd8bf531eca0
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_13-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBigIntKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 8
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'bigint'. [array_13.ts:2:9]
diff --git a/es2panda/test/compiler/ts/array_13.ts b/es2panda/test/compiler/ts/array_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1932e30a6ab3c99cd252cb90638958927a1bfa63
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_13.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint[];
+a = [5n,"foo"];
diff --git a/es2panda/test/compiler/ts/array_14-expected.txt b/es2panda/test/compiler/ts/array_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f56a52c4b5942f29bdfc6d48ff528ebafd698802
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_14-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBigIntKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'bigint'. [array_14.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_14.ts b/es2panda/test/compiler/ts/array_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..27ba5ff40783b874032a8defd86ec5981b4d6c2f
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_14.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint[];
+a = ["foo",5n];
diff --git a/es2panda/test/compiler/ts/array_15-expected.txt b/es2panda/test/compiler/ts/array_15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c2a132421f8c96558dfb9ba3c3d8372d14b56898
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_15-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBigIntKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 8
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [array_15.ts:2:9]
diff --git a/es2panda/test/compiler/ts/array_15.ts b/es2panda/test/compiler/ts/array_15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2bd7ba7ce0f833345e9b8c973c4d6022bc6e4827
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_15.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint[];
+a = [5n,5];
diff --git a/es2panda/test/compiler/ts/array_16-expected.txt b/es2panda/test/compiler/ts/array_16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3b7fd5001b85b1ba02d0dfc3e67ab9c3c34423a9
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_16-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBigIntKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [array_16.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_16.ts b/es2panda/test/compiler/ts/array_16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f2a8c0ebeb3c8b39654ba5dcf6060796784c5e0e
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_16.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint[];
+a = [5,5n];
diff --git a/es2panda/test/compiler/ts/array_17-expected.txt b/es2panda/test/compiler/ts/array_17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c368ec059d2b3919b317164f669527cb691a2a95
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_17-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBigIntKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 8
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'bigint'. [array_17.ts:2:9]
diff --git a/es2panda/test/compiler/ts/array_17.ts b/es2panda/test/compiler/ts/array_17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..39d8825542d91d7873a6615a2d319e0ec2c49e1f
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_17.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint[];
+a = [5n,false];
diff --git a/es2panda/test/compiler/ts/array_18-expected.txt b/es2panda/test/compiler/ts/array_18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dbacad2a124521f822492445dd1cb65dbe3473fa
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_18-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBigIntKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'bigint'. [array_18.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_18.ts b/es2panda/test/compiler/ts/array_18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1e0b9ccab662e8a3ae8dd0364e15fea96b650898
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_18.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint[];
+a = [false,5n];
diff --git a/es2panda/test/compiler/ts/array_19-expected.txt b/es2panda/test/compiler/ts/array_19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..94e7c8bf2fd814e987adc992346653c9966f1a51
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_19-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'boolean'. [array_19.ts:2:12]
diff --git a/es2panda/test/compiler/ts/array_19.ts b/es2panda/test/compiler/ts/array_19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3f07d16df7ec958ed5d431ff612f22fcbdeb7502
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_19.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean[];
+a = [false,"foo"];
diff --git a/es2panda/test/compiler/ts/array_2-expected.txt b/es2panda/test/compiler/ts/array_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..445363a2712a8a0a5ce6050de36d2d9a300558ad
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_2-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [array_2.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_2.ts b/es2panda/test/compiler/ts/array_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c03c68d6eb4e7e03f8406906456b341279cfb54a
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_2.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+a = [5,"foo"];
diff --git a/es2panda/test/compiler/ts/array_20-expected.txt b/es2panda/test/compiler/ts/array_20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eb8fd7639e604c98e0494779f426ad0440e51acd
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_20-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'boolean'. [array_20.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_20.ts b/es2panda/test/compiler/ts/array_20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a8e9c817d82fb5c72df8717cedeb1893c2a6d7c2
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_20.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean[];
+a = ["foo",false];
diff --git a/es2panda/test/compiler/ts/array_21-expected.txt b/es2panda/test/compiler/ts/array_21-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..15c9c123c3d7f92652606661c4aa3d4a57febdd4
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_21-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [array_21.ts:2:12]
diff --git a/es2panda/test/compiler/ts/array_21.ts b/es2panda/test/compiler/ts/array_21.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3ca67b5c4fea190687be155a97eba112674a3eea
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_21.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean[];
+a = [false,5];
diff --git a/es2panda/test/compiler/ts/array_22-expected.txt b/es2panda/test/compiler/ts/array_22-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f81fd136140088c7f9052ac6db4a450cbb4bbee8
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_22-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [array_22.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_22.ts b/es2panda/test/compiler/ts/array_22.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b2757be0fe04ec4931cbe8e8c7b59a70d0f64022
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_22.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean[];
+a = [5,false];
diff --git a/es2panda/test/compiler/ts/array_23-expected.txt b/es2panda/test/compiler/ts/array_23-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6a237b832f0d73c113ce0a17aae4d81ba71278f7
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_23-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'boolean'. [array_23.ts:2:12]
diff --git a/es2panda/test/compiler/ts/array_23.ts b/es2panda/test/compiler/ts/array_23.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d674f07a76ed6b9f502161ab2ef3ec1424017bea
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_23.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean[];
+a = [false,5n];
diff --git a/es2panda/test/compiler/ts/array_24-expected.txt b/es2panda/test/compiler/ts/array_24-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3e566fba7464430a4ae972345260028ad93f568e
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_24-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 8
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'boolean'. [array_24.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_24.ts b/es2panda/test/compiler/ts/array_24.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3de8e7d6d2cdbbcaaab6529dea93bb78bc288186
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_24.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean[];
+a = [5n,false];
diff --git a/es2panda/test/compiler/ts/array_3-expected.txt b/es2panda/test/compiler/ts/array_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..68dfe9ac83db40d0f652a99b848db2c91c26207a
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_3-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string'. [array_3.ts:2:12]
diff --git a/es2panda/test/compiler/ts/array_3.ts b/es2panda/test/compiler/ts/array_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..80f4ff655ebb2e611f2afb86d2d9154e1beeaba8
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_3.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+a = ["foo",false];
diff --git a/es2panda/test/compiler/ts/array_4-expected.txt b/es2panda/test/compiler/ts/array_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..12a1fa2d69547ffefaec5a658e8035092942d2ec
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_4-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string'. [array_4.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_4.ts b/es2panda/test/compiler/ts/array_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..17e40617d0c6ebef848845339a003ef55b794fe6
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_4.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+a = [false,"foo"];
diff --git a/es2panda/test/compiler/ts/array_5-expected.txt b/es2panda/test/compiler/ts/array_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..09cb8ec7cb345b5486a129069f52d9199c328d85
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_5-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'string'. [array_5.ts:2:12]
diff --git a/es2panda/test/compiler/ts/array_5.ts b/es2panda/test/compiler/ts/array_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..907baf2e5e35074fb22b2d81d8ae242ed8e3a0ac
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_5.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+a = ["foo",5n];
diff --git a/es2panda/test/compiler/ts/array_6-expected.txt b/es2panda/test/compiler/ts/array_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..67bfe597c87341780b1715183fb32e3a4f7d61ff
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_6-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "BigIntLiteral",
+              "value": "",
+              "bigint": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 8
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'string'. [array_6.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_6.ts b/es2panda/test/compiler/ts/array_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bb8e142b2b1652ff62dc59e56b9030ae4c0173b5
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string[];
+a = [5n,"foo"];
diff --git a/es2panda/test/compiler/ts/array_7-expected.txt b/es2panda/test/compiler/ts/array_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..86d90875bf02aa43ab9520140a6a779f270679d0
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_7-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [array_7.ts:2:8]
diff --git a/es2panda/test/compiler/ts/array_7.ts b/es2panda/test/compiler/ts/array_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2ce2d03bee62dcecc67955b9a2502cbe0881cade
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_7.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[];
+a = [5,"foo"];
diff --git a/es2panda/test/compiler/ts/array_8-expected.txt b/es2panda/test/compiler/ts/array_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..25bc4258bd29c5fb2c8ba14ac1c77e17f61b2d9e
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_8-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [array_8.ts:2:6]
diff --git a/es2panda/test/compiler/ts/array_8.ts b/es2panda/test/compiler/ts/array_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a053bd490ef0d3c63b34ca6a27ab2f187839162a
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_8.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[];
+a = ["foo",5];
diff --git a/es2panda/test/compiler/ts/array_9-expected.txt b/es2panda/test/compiler/ts/array_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f0853be994971a59b95dbb0967c0e27e8aabe8aa
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_9-expected.txt
@@ -0,0 +1,172 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": false,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'number'. [array_9.ts:2:8]
diff --git a/es2panda/test/compiler/ts/array_9.ts b/es2panda/test/compiler/ts/array_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc24181d40053c139471d2636944801ee2506fbd
--- /dev/null
+++ b/es2panda/test/compiler/ts/array_9.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[];
+a = [5,false];
diff --git a/es2panda/test/compiler/ts/as_expression_1-expected.txt b/es2panda/test/compiler/ts/as_expression_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d74f3fd14a18d6a26388af10ea196dc2235deeee
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_1-expected.txt
@@ -0,0 +1,100 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 18
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 1
+    }
+  }
+}
+TypeError: Conversion of type 'string' to type 'number' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. [as_expression_1.ts:1:9]
diff --git a/es2panda/test/compiler/ts/as_expression_1.ts b/es2panda/test/compiler/ts/as_expression_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..362cf63563eac28d23ef9dc6711cb5e22c8386ec
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = "foo" as number;
diff --git a/es2panda/test/compiler/ts/as_expression_10-expected.txt b/es2panda/test/compiler/ts/as_expression_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d1b8ce40aeaf9d867f6b2f26693a20d1bb4eccc
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_10-expected.txt
@@ -0,0 +1,228 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'readonly [5, 5, 5, 5]'. [as_expression_10.ts:2:1]
diff --git a/es2panda/test/compiler/ts/as_expression_10.ts b/es2panda/test/compiler/ts/as_expression_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..225cb02346c5e25bba75115dda6f2cfc1e6e0f5b
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_10.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a = 5;
diff --git a/es2panda/test/compiler/ts/as_expression_11-expected.txt b/es2panda/test/compiler/ts/as_expression_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53076f9b745cbba06697165f97f607e0b54dc8fa
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_11-expected.txt
@@ -0,0 +1,257 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 3
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to '0' because it is a read-only property. [as_expression_11.ts:2:3]
diff --git a/es2panda/test/compiler/ts/as_expression_11.ts b/es2panda/test/compiler/ts/as_expression_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..58763904e1934492928d39b77ecdc9143b4095f2
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_11.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a[0] = 5;
diff --git a/es2panda/test/compiler/ts/as_expression_12-expected.txt b/es2panda/test/compiler/ts/as_expression_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..67e68e4482352c10849d9b2e81f5b148a4482357
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_12-expected.txt
@@ -0,0 +1,257 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 3
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to '1' because it is a read-only property. [as_expression_12.ts:2:3]
diff --git a/es2panda/test/compiler/ts/as_expression_12.ts b/es2panda/test/compiler/ts/as_expression_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..00ae34de42d46e887c51fd05e6574c3bb477c663
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_12.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a[1] = 5;
diff --git a/es2panda/test/compiler/ts/as_expression_13-expected.txt b/es2panda/test/compiler/ts/as_expression_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a1c657097f35e978abce7b61e184af3c8dc0e656
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_13-expected.txt
@@ -0,0 +1,257 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 3
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to '2' because it is a read-only property. [as_expression_13.ts:2:3]
diff --git a/es2panda/test/compiler/ts/as_expression_13.ts b/es2panda/test/compiler/ts/as_expression_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..af869f1606a611735aa5037cb49ac3dbe9d3029f
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_13.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a[2] = 5;
diff --git a/es2panda/test/compiler/ts/as_expression_14-expected.txt b/es2panda/test/compiler/ts/as_expression_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5ae25f1d8363126a2c8bfe1ff3f419d005425540
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_14-expected.txt
@@ -0,0 +1,257 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 3,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 3
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to '3' because it is a read-only property. [as_expression_14.ts:2:3]
diff --git a/es2panda/test/compiler/ts/as_expression_14.ts b/es2panda/test/compiler/ts/as_expression_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c4a9cf70eacbc703c9d490ae502f6f934937cb78
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_14.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a[3] = 5;
diff --git a/es2panda/test/compiler/ts/as_expression_15-expected.txt b/es2panda/test/compiler/ts/as_expression_15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..86eb885bd86a338097af2b2c0db09d87f5836a25
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_15-expected.txt
@@ -0,0 +1,257 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 30
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 25
+                },
+                "end": {
+                  "line": 1,
+                  "column": 30
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 31
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 4,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 3
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Tuple type 'readonly [5, 5, 5, 5]' of length '4' has no element at index '4'. [as_expression_15.ts:2:3]
diff --git a/es2panda/test/compiler/ts/as_expression_15.ts b/es2panda/test/compiler/ts/as_expression_15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2cbeebed8d471485c68fab7380904a982c5e6864
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_15.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5, 5, 5, 5] as const;
+a[4] = 5;
diff --git a/es2panda/test/compiler/ts/as_expression_2-expected.txt b/es2panda/test/compiler/ts/as_expression_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a92d47bb871ff8ed48f07377f499abd98940adbf
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_2-expected.txt
@@ -0,0 +1,143 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TSAsExpression",
+        "expression": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "typeAnnotation": {
+          "type": "TSTypeReference",
+          "typeName": {
+            "type": "Identifier",
+            "name": "const",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 6
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 6
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals. [as_expression_2.ts:2:1]
diff --git a/es2panda/test/compiler/ts/as_expression_2.ts b/es2panda/test/compiler/ts/as_expression_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c68ab4366c78061cabcb022917086ccc46427e2c
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_2.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+a as const;
diff --git a/es2panda/test/compiler/ts/as_expression_3-expected.txt b/es2panda/test/compiler/ts/as_expression_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ca7a905bb2018da715e8835de3693cd09ff16036
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_3-expected.txt
@@ -0,0 +1,285 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '4' is not assignable to type '5'. [as_expression_3.ts:2:6]
diff --git a/es2panda/test/compiler/ts/as_expression_3.ts b/es2panda/test/compiler/ts/as_expression_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b0e9d7e8e3689f73bfdb1387fe7083ba8a825fa3
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_3.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a = [4,5,5,5];
diff --git a/es2panda/test/compiler/ts/as_expression_4-expected.txt b/es2panda/test/compiler/ts/as_expression_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a606afec1356cb89cb613e05d7756e8ed0af9316
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_4-expected.txt
@@ -0,0 +1,285 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '4' is not assignable to type '5'. [as_expression_4.ts:2:8]
diff --git a/es2panda/test/compiler/ts/as_expression_4.ts b/es2panda/test/compiler/ts/as_expression_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56eb4f75c29d7fcd02cfc1f45b8d425345a90a02
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_4.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a = [5,4,5,5];
diff --git a/es2panda/test/compiler/ts/as_expression_5-expected.txt b/es2panda/test/compiler/ts/as_expression_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..56d0e25d38b66c05ead4325032061fd9b94cfb66
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_5-expected.txt
@@ -0,0 +1,285 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '4' is not assignable to type '5'. [as_expression_5.ts:2:10]
diff --git a/es2panda/test/compiler/ts/as_expression_5.ts b/es2panda/test/compiler/ts/as_expression_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..77cbbbb7d37b9ac85c1b7bcd9b7a9b2e6751602d
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_5.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a = [5,5,4,5];
diff --git a/es2panda/test/compiler/ts/as_expression_6-expected.txt b/es2panda/test/compiler/ts/as_expression_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..26df7e458ec62a62f72c8dc12c57a337d69a8a31
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_6-expected.txt
@@ -0,0 +1,285 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 30
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 25
+                },
+                "end": {
+                  "line": 1,
+                  "column": 30
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 31
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 15
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 18
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '4' is not assignable to type '5'. [as_expression_6.ts:2:15]
diff --git a/es2panda/test/compiler/ts/as_expression_6.ts b/es2panda/test/compiler/ts/as_expression_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..92d8f8d6ae6c322ff51a4f04a00b8b6ffe45fb88
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5, 5, 5, 5] as const;
+a = [5, 5, 5, 4];
diff --git a/es2panda/test/compiler/ts/as_expression_7-expected.txt b/es2panda/test/compiler/ts/as_expression_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b8d37b6a0da4b18a953a8e0e12bddd3a4563b5e4
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_7-expected.txt
@@ -0,0 +1,299 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 14
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '[5, 5, 5, 5, 5]' is not assignable to type 'readonly [5, 5, 5, 5]'. [as_expression_7.ts:2:1]
diff --git a/es2panda/test/compiler/ts/as_expression_7.ts b/es2panda/test/compiler/ts/as_expression_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..255d5641ef4a6b83c2b39eadb29fce9c3cb4c22d
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_7.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a = [5,5,5,5,5];
diff --git a/es2panda/test/compiler/ts/as_expression_8-expected.txt b/es2panda/test/compiler/ts/as_expression_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e66afc663540bfcdc5a1ac20438d7f7b24c91529
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_8-expected.txt
@@ -0,0 +1,271 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '[5, 5, 5]' is not assignable to type 'readonly [5, 5, 5, 5]'. [as_expression_8.ts:2:1]
diff --git a/es2panda/test/compiler/ts/as_expression_8.ts b/es2panda/test/compiler/ts/as_expression_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..159c2d784b4a1a6e47d1b6aa46f350cdc606ace4
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_8.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a = [5,5,5];
diff --git a/es2panda/test/compiler/ts/as_expression_9-expected.txt b/es2panda/test/compiler/ts/as_expression_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..862d7f62a5327100009e7b146e618c9a36b7a3c9
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_9-expected.txt
@@ -0,0 +1,257 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '[5, 5]' is not assignable to type 'readonly [5, 5, 5, 5]'. [as_expression_9.ts:2:1]
diff --git a/es2panda/test/compiler/ts/as_expression_9.ts b/es2panda/test/compiler/ts/as_expression_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..55d5491dd417b089a45ac756fe657cfef99ff07b
--- /dev/null
+++ b/es2panda/test/compiler/ts/as_expression_9.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [5,5,5,5] as const;
+a = [5,5];
diff --git a/es2panda/test/compiler/ts/assignment_never-expected.txt b/es2panda/test/compiler/ts/assignment_never-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a6878af6553ea9eeb29e50e96fe50e1488600b31
--- /dev/null
+++ b/es2panda/test/compiler/ts/assignment_never-expected.txt
@@ -0,0 +1,87 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNeverKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NullLiteral",
+            "value": null,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 16
+              },
+              "end": {
+                "line": 1,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 20
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'null' is not assignable to type 'never' [assignment_never.ts:1:5]
diff --git a/es2panda/test/compiler/ts/assignment_never.ts b/es2panda/test/compiler/ts/assignment_never.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4bafa942475772040685e1ff8c5fb75239d48398
--- /dev/null
+++ b/es2panda/test/compiler/ts/assignment_never.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let a: never = null;
diff --git a/es2panda/test/compiler/ts/assignment_unknown-expected.txt b/es2panda/test/compiler/ts/assignment_unknown-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4d4e9485ccb2d14eba14224322ab1d4f4fb95809
--- /dev/null
+++ b/es2panda/test/compiler/ts/assignment_unknown-expected.txt
@@ -0,0 +1,409 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "variable",
+            "typeAnnotation": {
+              "type": "TSUnknownKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 15
+                },
+                "end": {
+                  "line": 1,
+                  "column": 22
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 13
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "variable",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NullLiteral",
+          "value": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 12
+            },
+            "end": {
+              "line": 3,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "variable",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": true,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 12
+            },
+            "end": {
+              "line": 4,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "variable",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 12
+            },
+            "end": {
+              "line": 5,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "variable",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 12
+            },
+            "end": {
+              "line": 6,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "variable",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 12
+            },
+            "end": {
+              "line": 7,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "variable",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 12
+            },
+            "end": {
+              "line": 8,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 9,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/assignment_unknown.ts b/es2panda/test/compiler/ts/assignment_unknown.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d50573d65787710c0086cc97c9671c92fd6229f0
--- /dev/null
+++ b/es2panda/test/compiler/ts/assignment_unknown.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let variable: unknown;
+
+variable = null;
+variable = true;
+variable = 12;
+variable = "Hello World";
+variable = [];
+variable = {};
diff --git a/es2panda/test/compiler/ts/cannotAssignToConst-expected.txt b/es2panda/test/compiler/ts/cannotAssignToConst-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d48b72b9c386b59ed4d626ea64e18fac1902902
--- /dev/null
+++ b/es2panda/test/compiler/ts/cannotAssignToConst-expected.txt
@@ -0,0 +1,130 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 7
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 11
+              },
+              "end": {
+                "line": 1,
+                "column": 12
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 7
+            },
+            "end": {
+              "line": 1,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "const",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 6,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 7
+    }
+  }
+}
+TypeError: Cannot assign to 'a' because it is a constant [cannotAssignToConst.ts:2:1]
diff --git a/es2panda/test/compiler/ts/cannotAssignToConst.ts b/es2panda/test/compiler/ts/cannotAssignToConst.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9bde3ebc760191dc64047a89bfb29762e125a067
--- /dev/null
+++ b/es2panda/test/compiler/ts/cannotAssignToConst.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+const a = 5;
+a = 6;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/constUsedBeforeDeclaration-expected.txt b/es2panda/test/compiler/ts/constUsedBeforeDeclaration-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..12b074a3f9f2139ee8c47f3682e9e9da8e80f7d1
--- /dev/null
+++ b/es2panda/test/compiler/ts/constUsedBeforeDeclaration-expected.txt
@@ -0,0 +1,130 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 7
+              },
+              "end": {
+                "line": 2,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 6,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 11
+              },
+              "end": {
+                "line": 2,
+                "column": 12
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 7
+            },
+            "end": {
+              "line": 2,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "const",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 13
+    }
+  }
+}
+TypeError: Block-scoped variable 'a' used before its declaration [constUsedBeforeDeclaration.ts:1:1]
diff --git a/es2panda/test/compiler/ts/constUsedBeforeDeclaration.ts b/es2panda/test/compiler/ts/constUsedBeforeDeclaration.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f05eb4bfd6f7ad7daa129cb3edc417355cf8743d
--- /dev/null
+++ b/es2panda/test/compiler/ts/constUsedBeforeDeclaration.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a + 2;
+const a = 6;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall-expected.txt b/es2panda/test/compiler/ts/functionCall-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..188d10ff4f5329ea47f2692fbca3fdd1be01a58b
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall-expected.txt
@@ -0,0 +1,5451 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 19
+                },
+                "end": {
+                  "line": 1,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 16
+              },
+              "end": {
+                "line": 1,
+                "column": 17
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSVoidKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 28
+            },
+            "end": {
+              "line": 1,
+              "column": 32
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 33
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 7
+              },
+              "end": {
+                "line": 4,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 10
+            },
+            "end": {
+              "line": 6,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 19
+                },
+                "end": {
+                  "line": 6,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 16
+              },
+              "end": {
+                "line": 6,
+                "column": 17
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 28
+            },
+            "end": {
+              "line": 6,
+              "column": 34
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 35
+            },
+            "end": {
+              "line": 8,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "callAbleObj1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 6
+          },
+          "end": {
+            "line": 10,
+            "column": 18
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTypeLiteral",
+        "members": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 18
+                },
+                "end": {
+                  "line": 11,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 21
+          },
+          "end": {
+            "line": 12,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 10
+            },
+            "end": {
+              "line": 14,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "fn",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "callAbleObj1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 20
+                },
+                "end": {
+                  "line": 14,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 16
+              },
+              "end": {
+                "line": 14,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 35
+            },
+            "end": {
+              "line": 14,
+              "column": 41
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "CallExpression",
+                "callee": {
+                  "type": "Identifier",
+                  "name": "fn",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 14
+                    }
+                  }
+                },
+                "arguments": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 16
+                      }
+                    }
+                  }
+                ],
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 17
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 5
+                },
+                "end": {
+                  "line": 15,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 42
+            },
+            "end": {
+              "line": 16,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 1
+          },
+          "end": {
+            "line": 16,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj1",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "callAbleObj1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 11
+                },
+                "end": {
+                  "line": 18,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 5
+              },
+              "end": {
+                "line": 18,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 5
+            },
+            "end": {
+              "line": 18,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func2",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 7
+                },
+                "end": {
+                  "line": 19,
+                  "column": 12
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "CallExpression",
+                "callee": {
+                  "type": "Identifier",
+                  "name": "func3",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 18
+                    }
+                  }
+                },
+                "arguments": [
+                  {
+                    "type": "Identifier",
+                    "name": "obj1",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 19,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 19,
+                        "column": 23
+                      }
+                    }
+                  }
+                ],
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 7
+              },
+              "end": {
+                "line": 19,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 10
+            },
+            "end": {
+              "line": 21,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 19
+                },
+                "end": {
+                  "line": 21,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 16
+              },
+              "end": {
+                "line": 21,
+                "column": 17
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 28
+            },
+            "end": {
+              "line": 21,
+              "column": 34
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ExpressionStatement",
+              "expression": {
+                "type": "UpdateExpression",
+                "operator": "++",
+                "prefix": false,
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 6
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 8
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 5
+                },
+                "end": {
+                  "line": 22,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ConditionalExpression",
+                "test": {
+                  "type": "BinaryExpression",
+                  "operator": "<",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 0,
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 17
+                    }
+                  }
+                },
+                "consequent": {
+                  "type": "CallExpression",
+                  "callee": {
+                    "type": "Identifier",
+                    "name": "func4",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "arguments": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 27
+                        }
+                      }
+                    }
+                  ],
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 28
+                    }
+                  }
+                },
+                "alternate": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 32
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 5
+                },
+                "end": {
+                  "line": 23,
+                  "column": 33
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 35
+            },
+            "end": {
+              "line": 24,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 1
+            },
+            "end": {
+              "line": 26,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "UnaryExpression",
+            "operator": "-",
+            "prefix": true,
+            "argument": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 8
+                },
+                "end": {
+                  "line": 26,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 7
+              },
+              "end": {
+                "line": 26,
+                "column": 9
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 7
+              },
+              "end": {
+                "line": 27,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func5",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 10
+            },
+            "end": {
+              "line": 29,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 19
+                },
+                "end": {
+                  "line": 29,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 16
+              },
+              "end": {
+                "line": 29,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 30
+                },
+                "end": {
+                  "line": 29,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 27
+              },
+              "end": {
+                "line": 29,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 41
+                },
+                "end": {
+                  "line": 29,
+                  "column": 42
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 38
+              },
+              "end": {
+                "line": 29,
+                "column": 42
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 5
+                },
+                "end": {
+                  "line": 30,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 44
+            },
+            "end": {
+              "line": 31,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 31,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func5",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 1
+            },
+            "end": {
+              "line": 33,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 7
+              },
+              "end": {
+                "line": 33,
+                "column": 8
+              }
+            }
+          },
+          {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 10
+              },
+              "end": {
+                "line": 33,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 1
+          },
+          "end": {
+            "line": 33,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func5",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 1
+            },
+            "end": {
+              "line": 34,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 7
+              },
+              "end": {
+                "line": 34,
+                "column": 8
+              }
+            }
+          },
+          {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 10
+              },
+              "end": {
+                "line": 34,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 17
+              },
+              "end": {
+                "line": 34,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "BooleanLiteral",
+            "value": true,
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 20
+              },
+              "end": {
+                "line": 34,
+                "column": 24
+              }
+            }
+          },
+          {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 26
+              },
+              "end": {
+                "line": 34,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 1
+          },
+          "end": {
+            "line": 34,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 10
+            },
+            "end": {
+              "line": 36,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 16
+              },
+              "end": {
+                "line": 36,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 29
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 23
+                },
+                "end": {
+                  "line": 36,
+                  "column": 31
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 19
+              },
+              "end": {
+                "line": 36,
+                "column": 20
+              }
+            }
+          },
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 36
+                },
+                "end": {
+                  "line": 36,
+                  "column": 37
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 39
+                },
+                "end": {
+                  "line": 36,
+                  "column": 47
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 33
+              },
+              "end": {
+                "line": 36,
+                "column": 47
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 5
+                },
+                "end": {
+                  "line": 37,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 49
+            },
+            "end": {
+              "line": 38,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 1
+          },
+          "end": {
+            "line": 38,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 1
+            },
+            "end": {
+              "line": 40,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 7
+              },
+              "end": {
+                "line": 40,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 40,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 1
+            },
+            "end": {
+              "line": 41,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "BooleanLiteral",
+            "value": false,
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 7
+              },
+              "end": {
+                "line": 41,
+                "column": 12
+              }
+            }
+          },
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 14
+              },
+              "end": {
+                "line": 41,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 1
+          },
+          "end": {
+            "line": 41,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 1
+            },
+            "end": {
+              "line": 42,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 7
+              },
+              "end": {
+                "line": 42,
+                "column": 9
+              }
+            }
+          },
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 17
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 11
+              },
+              "end": {
+                "line": 42,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 20
+              },
+              "end": {
+                "line": 42,
+                "column": 21
+              }
+            }
+          },
+          {
+            "type": "NumberLiteral",
+            "value": 3,
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 23
+              },
+              "end": {
+                "line": 42,
+                "column": 24
+              }
+            }
+          },
+          {
+            "type": "NumberLiteral",
+            "value": 4,
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 26
+              },
+              "end": {
+                "line": 42,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 1
+          },
+          "end": {
+            "line": 42,
+            "column": 28
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 42,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func7",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 44,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 44,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 44,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 44,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 44,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 44,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 44,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 44,
+                          "column": 27
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 44,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 44,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 44,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 45
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 44,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 44,
+                            "column": 51
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 44,
+                          "column": 47
+                        },
+                        "end": {
+                          "line": 44,
+                          "column": 51
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 44,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 44,
+                        "column": 60
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 44,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 44,
+                  "column": 12
+                },
+                "end": {
+                  "line": 44,
+                  "column": 62
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 44,
+                "column": 5
+              },
+              "end": {
+                "line": 44,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 44,
+              "column": 5
+            },
+            "end": {
+              "line": 44,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 44,
+          "column": 1
+        },
+        "end": {
+          "line": 44,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 8
+                },
+                "end": {
+                  "line": 45,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func7",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 17
+                },
+                "end": {
+                  "line": 45,
+                  "column": 22
+                }
+              }
+            },
+            "arguments": [],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 17
+              },
+              "end": {
+                "line": 45,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 5
+            },
+            "end": {
+              "line": 45,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 45,
+          "column": 1
+        },
+        "end": {
+          "line": 45,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 8
+                },
+                "end": {
+                  "line": 46,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 46,
+                "column": 5
+              },
+              "end": {
+                "line": 46,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func7",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 17
+                },
+                "end": {
+                  "line": 46,
+                  "column": 22
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 46,
+                "column": 17
+              },
+              "end": {
+                "line": 46,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 46,
+              "column": 5
+            },
+            "end": {
+              "line": 46,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 46,
+          "column": 1
+        },
+        "end": {
+          "line": 46,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 8
+                },
+                "end": {
+                  "line": 47,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 5
+              },
+              "end": {
+                "line": 47,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func7",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 17
+                },
+                "end": {
+                  "line": 47,
+                  "column": 22
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 47,
+                    "column": 24
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 47,
+                    "column": 31
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 17
+              },
+              "end": {
+                "line": 47,
+                "column": 32
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 5
+            },
+            "end": {
+              "line": 47,
+              "column": 32
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 47,
+          "column": 1
+        },
+        "end": {
+          "line": 47,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func8",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 49,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 31
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 49,
+                          "column": 31
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 42
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 44
+                        },
+                        "end": {
+                          "line": 49,
+                          "column": 45
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 49,
+                              "column": 50
+                            },
+                            "end": {
+                              "line": 49,
+                              "column": 56
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 58
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 47
+                        },
+                        "end": {
+                          "line": 49,
+                          "column": 48
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 63
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 64
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 49,
+                              "column": 66
+                            },
+                            "end": {
+                              "line": 49,
+                              "column": 72
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 66
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 74
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 60
+                        },
+                        "end": {
+                          "line": 49,
+                          "column": 74
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 77
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 83
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 84
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 89
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 95
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 86
+                        },
+                        "end": {
+                          "line": 49,
+                          "column": 87
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 100
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 107
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 97
+                        },
+                        "end": {
+                          "line": 49,
+                          "column": 98
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 110
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 116
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 85
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 118
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 12
+                },
+                "end": {
+                  "line": 49,
+                  "column": 118
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 49,
+                "column": 5
+              },
+              "end": {
+                "line": 49,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 49,
+              "column": 5
+            },
+            "end": {
+              "line": 49,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 49,
+          "column": 1
+        },
+        "end": {
+          "line": 49,
+          "column": 119
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 8
+                },
+                "end": {
+                  "line": 50,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 5
+              },
+              "end": {
+                "line": 50,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func8",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 18
+                },
+                "end": {
+                  "line": 50,
+                  "column": 23
+                }
+              }
+            },
+            "arguments": [],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 18
+              },
+              "end": {
+                "line": 50,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 5
+            },
+            "end": {
+              "line": 50,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 50,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 8
+                },
+                "end": {
+                  "line": 51,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 51,
+                "column": 5
+              },
+              "end": {
+                "line": 51,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func8",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 18
+                },
+                "end": {
+                  "line": 51,
+                  "column": 23
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 51,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 51,
+                    "column": 25
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 51,
+                "column": 18
+              },
+              "end": {
+                "line": 51,
+                "column": 26
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 51,
+              "column": 5
+            },
+            "end": {
+              "line": 51,
+              "column": 26
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 51,
+          "column": 1
+        },
+        "end": {
+          "line": 51,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "g",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 8
+                },
+                "end": {
+                  "line": 52,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 5
+              },
+              "end": {
+                "line": 52,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func8",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 18
+                },
+                "end": {
+                  "line": 52,
+                  "column": 23
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 31
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 18
+              },
+              "end": {
+                "line": 52,
+                "column": 32
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 52,
+              "column": 5
+            },
+            "end": {
+              "line": 52,
+              "column": 32
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 52,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "h",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 8
+                },
+                "end": {
+                  "line": 53,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 5
+              },
+              "end": {
+                "line": 53,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func8",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 18
+                },
+                "end": {
+                  "line": 53,
+                  "column": 23
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 53,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 53,
+                        "column": 33
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 53,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 53,
+                        "column": 40
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 41
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 45
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 18
+              },
+              "end": {
+                "line": 53,
+                "column": 46
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 53,
+              "column": 5
+            },
+            "end": {
+              "line": 53,
+              "column": 46
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 53,
+          "column": 1
+        },
+        "end": {
+          "line": 53,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "i",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 8
+                },
+                "end": {
+                  "line": 54,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 5
+              },
+              "end": {
+                "line": 54,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func8",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 17
+                },
+                "end": {
+                  "line": 54,
+                  "column": 22
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 54,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 54,
+                        "column": 33
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 34
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 17
+              },
+              "end": {
+                "line": 54,
+                "column": 35
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 5
+            },
+            "end": {
+              "line": 54,
+              "column": 35
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 54,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "j",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 8
+                },
+                "end": {
+                  "line": 55,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 55,
+                "column": 5
+              },
+              "end": {
+                "line": 55,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func8",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 17
+                },
+                "end": {
+                  "line": 55,
+                  "column": 22
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 55,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 55,
+                        "column": 33
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 34
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 37
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 40
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 43
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 55,
+                "column": 17
+              },
+              "end": {
+                "line": 55,
+                "column": 44
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 55,
+              "column": 5
+            },
+            "end": {
+              "line": 55,
+              "column": 44
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 55,
+          "column": 1
+        },
+        "end": {
+          "line": 55,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 10
+            },
+            "end": {
+              "line": 57,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 19
+                },
+                "end": {
+                  "line": 57,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 57,
+                "column": 16
+              },
+              "end": {
+                "line": 57,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 30
+                },
+                "end": {
+                  "line": 57,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 57,
+                "column": 27
+              },
+              "end": {
+                "line": 57,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 39
+            },
+            "end": {
+              "line": 57,
+              "column": 45
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 57,
+            "column": 1
+          },
+          "end": {
+            "line": 57,
+            "column": 46
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 57,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 10
+            },
+            "end": {
+              "line": 58,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 19
+                },
+                "end": {
+                  "line": 58,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 16
+              },
+              "end": {
+                "line": 58,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 30
+                },
+                "end": {
+                  "line": 58,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 27
+              },
+              "end": {
+                "line": 58,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSUnionType",
+          "types": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 39
+                },
+                "end": {
+                  "line": 58,
+                  "column": 45
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 48
+                },
+                "end": {
+                  "line": 58,
+                  "column": 54
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 39
+            },
+            "end": {
+              "line": 58,
+              "column": 54
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 58,
+            "column": 1
+          },
+          "end": {
+            "line": 58,
+            "column": 55
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 58,
+          "column": 55
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 10
+            },
+            "end": {
+              "line": 59,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 59,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 59,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 59,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 59,
+                      "column": 34
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 19
+                },
+                "end": {
+                  "line": 59,
+                  "column": 34
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 59,
+                "column": 16
+              },
+              "end": {
+                "line": 59,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 59,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 59,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 59,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 59,
+                      "column": 55
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 40
+                },
+                "end": {
+                  "line": 59,
+                  "column": 55
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 59,
+                "column": 36
+              },
+              "end": {
+                "line": 59,
+                "column": 37
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSUnionType",
+          "types": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 58
+                },
+                "end": {
+                  "line": 59,
+                  "column": 64
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 67
+                },
+                "end": {
+                  "line": 59,
+                  "column": 73
+                }
+              }
+            },
+            {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 76
+                },
+                "end": {
+                  "line": 59,
+                  "column": 83
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 58
+            },
+            "end": {
+              "line": 59,
+              "column": 83
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 5
+                },
+                "end": {
+                  "line": 60,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 84
+            },
+            "end": {
+              "line": 61,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 59,
+            "column": 1
+          },
+          "end": {
+            "line": 61,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 59,
+          "column": 1
+        },
+        "end": {
+          "line": 61,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "k",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 8
+                },
+                "end": {
+                  "line": 63,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 63,
+                "column": 5
+              },
+              "end": {
+                "line": 63,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func9",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 17
+                },
+                "end": {
+                  "line": 63,
+                  "column": 22
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 63,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 63,
+                    "column": 24
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 63,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 63,
+                    "column": 31
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 63,
+                "column": 17
+              },
+              "end": {
+                "line": 63,
+                "column": 32
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 5
+            },
+            "end": {
+              "line": 63,
+              "column": 32
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 63,
+          "column": 1
+        },
+        "end": {
+          "line": 63,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "l",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 23
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 8
+                },
+                "end": {
+                  "line": 64,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 5
+              },
+              "end": {
+                "line": 64,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func9",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 26
+                },
+                "end": {
+                  "line": 64,
+                  "column": 31
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 64,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 64,
+                    "column": 37
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 64,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 64,
+                    "column": 40
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 26
+              },
+              "end": {
+                "line": 64,
+                "column": 41
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 64,
+              "column": 5
+            },
+            "end": {
+              "line": 64,
+              "column": 41
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 64,
+          "column": 1
+        },
+        "end": {
+          "line": 64,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func10",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 66,
+              "column": 10
+            },
+            "end": {
+              "line": 66,
+              "column": 16
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 66,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 66,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 66,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 66,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "y",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 66,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 66,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 66,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 66,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 66,
+                  "column": 20
+                },
+                "end": {
+                  "line": 66,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 66,
+                "column": 17
+              },
+              "end": {
+                "line": 66,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSArrayType",
+          "elementType": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 66,
+                "column": 47
+              },
+              "end": {
+                "line": 66,
+                "column": 53
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 66,
+              "column": 47
+            },
+            "end": {
+              "line": 66,
+              "column": 55
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 66,
+            "column": 1
+          },
+          "end": {
+            "line": 66,
+            "column": 56
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 66,
+          "column": 1
+        },
+        "end": {
+          "line": 66,
+          "column": 56
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func10",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 67,
+              "column": 10
+            },
+            "end": {
+              "line": 67,
+              "column": 16
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "y",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 20
+                },
+                "end": {
+                  "line": 67,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 67,
+                "column": 17
+              },
+              "end": {
+                "line": 67,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSArrayType",
+          "elementType": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 67,
+                "column": 47
+              },
+              "end": {
+                "line": 67,
+                "column": 53
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 67,
+              "column": 47
+            },
+            "end": {
+              "line": 67,
+              "column": 55
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 67,
+            "column": 1
+          },
+          "end": {
+            "line": 67,
+            "column": 56
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 67,
+          "column": 1
+        },
+        "end": {
+          "line": 67,
+          "column": 56
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func10",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 68,
+              "column": 10
+            },
+            "end": {
+              "line": 68,
+              "column": 16
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 68,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 68,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 68,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 68,
+                            "column": 31
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 68,
+                            "column": 34
+                          },
+                          "end": {
+                            "line": 68,
+                            "column": 40
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 68,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 68,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 68,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 68,
+                      "column": 42
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 20
+                },
+                "end": {
+                  "line": 68,
+                  "column": 42
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 68,
+                "column": 17
+              },
+              "end": {
+                "line": 68,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 69,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 69,
+                        "column": 14
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 69,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 69,
+                        "column": 17
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 69,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 69,
+                        "column": 20
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 69,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 69,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 5
+                },
+                "end": {
+                  "line": 69,
+                  "column": 22
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 68,
+              "column": 44
+            },
+            "end": {
+              "line": 70,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 68,
+            "column": 1
+          },
+          "end": {
+            "line": 70,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 68,
+          "column": 1
+        },
+        "end": {
+          "line": 70,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "m",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 72,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 72,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 72,
+                  "column": 8
+                },
+                "end": {
+                  "line": 72,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 5
+              },
+              "end": {
+                "line": 72,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func10",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 72,
+                  "column": 19
+                },
+                "end": {
+                  "line": 72,
+                  "column": 25
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 72,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 72,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 72,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 72,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 72,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 72,
+                        "column": 32
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "y",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 72,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 72,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 72,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 72,
+                          "column": 42
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 72,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 72,
+                        "column": 42
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 72,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 72,
+                    "column": 44
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 19
+              },
+              "end": {
+                "line": 72,
+                "column": 45
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 72,
+              "column": 5
+            },
+            "end": {
+              "line": 72,
+              "column": 45
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 72,
+          "column": 1
+        },
+        "end": {
+          "line": 72,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "m",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 8
+                },
+                "end": {
+                  "line": 73,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 73,
+                "column": 5
+              },
+              "end": {
+                "line": 73,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func10",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 19
+                },
+                "end": {
+                  "line": 73,
+                  "column": 25
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 36
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 73,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 73,
+                        "column": 36
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "y",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 39
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 2,
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 41
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 42
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 73,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 73,
+                        "column": 42
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 44
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 73,
+                "column": 19
+              },
+              "end": {
+                "line": 73,
+                "column": 45
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 73,
+              "column": 5
+            },
+            "end": {
+              "line": 73,
+              "column": 45
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 73,
+          "column": 1
+        },
+        "end": {
+          "line": 73,
+          "column": 46
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 73,
+      "column": 46
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/functionCall.ts b/es2panda/test/compiler/ts/functionCall.ts
new file mode 100644
index 0000000000000000000000000000000000000000..83f3016abc2252bb58bf89ace2e427e47d37f643
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall.ts
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func1(a: number): void {
+
+}
+func1(5);
+
+function func2(a: number): number {
+    return a;
+}
+
+type callAbleObj1 = {
+    (a: number): number
+}
+
+function func3(fn: callAbleObj1): number {
+    return fn(5);
+}
+
+var obj1: callAbleObj1;
+func1(func2(func3(obj1)));
+
+function func4(a: number): number {
+    a++;
+    return a < 0 ? func4(a) : a;
+}
+
+func4(-5);
+func4(0);
+
+function func5(a: number, b: string, ...c) {
+    return 5;
+}
+
+func5(1, "foo");
+func5(1, "foo", 2, true, {});
+
+function func6(a, b?: string[], ...c: number[]) {
+    return true;
+}
+
+func6(2);
+func6(false, ["foo"]);
+func6({}, ["foo"], 2, 3, 4);
+
+var func7: { (a: number, b: string): number, (...a): string };
+var b: string = func7();
+var c: string = func7(1);
+var d: number = func7(1, "foo");
+
+var func8: { (a?: number, ...c): boolean, (a, b: string[], ...c: number[]): string, (a: number, b: boolean): number };
+var e: boolean = func8();
+var f: boolean = func8(1);
+var g: boolean = func8(2, true);
+var h: boolean = func8(2, ["foo", "bar"], {});
+var i: string = func8({}, ["bar"]);
+var j: string = func8({}, ["bar"], 3, 4, 5);
+
+function func9(a: number, b: string): number;
+function func9(a: string, b: number): number | string;
+function func9(a: number | string, b?: number | string): number | string | boolean {
+    return true;
+}
+
+var k: number = func9(1, "foo");
+var l: number | string = func9("bar", 2);
+
+function func10(a: { x: number, y: string }): number[];
+function func10(a: { x: string, y: number }): number[];
+function func10(a: { x: number | string }) {
+    return [1, 2, 3];
+}
+
+var m: number[] = func10({ x: 1, y: "foo" });
+var m: number[] = func10({ x: "bar", y: 2 });
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_1-expected.txt b/es2panda/test/compiler/ts/functionCall_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7eca9379c62544b8efb471980d0f9ea2e5af1a8d
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_1-expected.txt
@@ -0,0 +1,175 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 19
+                },
+                "end": {
+                  "line": 1,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSVoidKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 29
+            },
+            "end": {
+              "line": 1,
+              "column": 33
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 34
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 6
+              },
+              "end": {
+                "line": 4,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 13
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [functionCall_1.ts:4:6]
diff --git a/es2panda/test/compiler/ts/functionCall_1.ts b/es2panda/test/compiler/ts/functionCall_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..41428f19a71119a4016f45c4ef821bf1b34d8c8a
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_1.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(a : number) : void {
+
+}
+func("foo");
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_10-expected.txt b/es2panda/test/compiler/ts/functionCall_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c756536d067434a6e7ecb093c9d98938dcbaf2f
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_10-expected.txt
@@ -0,0 +1,288 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 55
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 67
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 58
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 70
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 76
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 78
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 78
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 79
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Expected 1-2 arguments, but got 0 [functionCall_10.ts:2:1]
diff --git a/es2panda/test/compiler/ts/functionCall_10.ts b/es2panda/test/compiler/ts/functionCall_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a01f54df83c79e30cab0fd475b2365cdd4c63df2
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_10.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var func: { (a: number, b: string): number, (a: string, b?: number): string };
+func();
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_11-expected.txt b/es2panda/test/compiler/ts/functionCall_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6365facda02eedd8b69269b20589e0b10883235e
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_11-expected.txt
@@ -0,0 +1,303 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 55
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 67
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 58
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 70
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 76
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 78
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 78
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 79
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 6
+              },
+              "end": {
+                "line": 2,
+                "column": 7
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 9
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [functionCall_11.ts:2:6]
diff --git a/es2panda/test/compiler/ts/functionCall_11.ts b/es2panda/test/compiler/ts/functionCall_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..38ae17125a686962e4910600041cdc66541d1928
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_11.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var func: { (a: number, b: string): number, (a: string, b?: number): string };
+func(1);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_12-expected.txt b/es2panda/test/compiler/ts/functionCall_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afa9e1121a123a108fd347487e05210ac7a0673b
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_12-expected.txt
@@ -0,0 +1,361 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 55
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 67
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 58
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 70
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 76
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 78
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 78
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 79
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 21
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 23
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 30
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 17
+              },
+              "end": {
+                "line": 2,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 31
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 32
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 32
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string' [functionCall_12.ts:2:5]
diff --git a/es2panda/test/compiler/ts/functionCall_12.ts b/es2panda/test/compiler/ts/functionCall_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc695b424efcd37bae9563143cd12bbfe260d0eb
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_12.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var func: { (a: number, b: string): number, (a: string, b?: number): string };
+var a: string = func(1, "foo");
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_13-expected.txt b/es2panda/test/compiler/ts/functionCall_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c7a8c3faa52d374833d57c310c1bafa9f5685eec
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_13-expected.txt
@@ -0,0 +1,470 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 43
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 44
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 49
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 55
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 57
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 62
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 63
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 71
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 65
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 73
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 73
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 76
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 82
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 83
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 88
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 94
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 85
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 86
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 99
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 106
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 96
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 97
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 109
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 115
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 117
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 117
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 118
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 21
+                }
+              }
+            },
+            "arguments": [],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 17
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 24
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string' [functionCall_13.ts:2:5]
diff --git a/es2panda/test/compiler/ts/functionCall_13.ts b/es2panda/test/compiler/ts/functionCall_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5b90709bcc92042e95767c76efee6a30847d9671
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_13.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var func: { (a?: number, ...c): boolean, (a, b: string[], ...c: number[]): string, (a: number, b: boolean): number };
+var a: string = func();
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_14-expected.txt b/es2panda/test/compiler/ts/functionCall_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b4a9adc670850a39eaad597e4905ffbd11e53767
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_14-expected.txt
@@ -0,0 +1,485 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 43
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 44
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 49
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 55
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 57
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 62
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 63
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 71
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 65
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 73
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 73
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 76
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 82
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 83
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 88
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 94
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 85
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 86
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 99
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 106
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 96
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 97
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 109
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 115
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 117
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 117
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 118
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 21
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 17
+              },
+              "end": {
+                "line": 2,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 25
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string' [functionCall_14.ts:2:5]
diff --git a/es2panda/test/compiler/ts/functionCall_14.ts b/es2panda/test/compiler/ts/functionCall_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..19b8013d252814dc6ec404b88c0205bf29e4c95f
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_14.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var func: { (a?: number, ...c): boolean, (a, b: string[], ...c: number[]): string, (a: number, b: boolean): number };
+var a: string = func(1);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_15-expected.txt b/es2panda/test/compiler/ts/functionCall_15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..49759abc329b33f736140db13f8666f01865e716
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_15-expected.txt
@@ -0,0 +1,425 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 40
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 43
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 48
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 54
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 56
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 46
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 64
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 70
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 64
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 72
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 58
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 72
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 75
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 81
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 82
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 87
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 93
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 84
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 85
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 98
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 105
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 95
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 96
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 108
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 114
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 83
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 116
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 116
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 117
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Expected at least 1 arguments, but got 0. [functionCall_15.ts:2:1]
diff --git a/es2panda/test/compiler/ts/functionCall_15.ts b/es2panda/test/compiler/ts/functionCall_15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4c790a90725873a7c7dd85e148e4be498e4dca19
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_15.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var func: { (a: number, ...c): boolean, (a, b: string[], ...c: number[]): string, (a: number, b: boolean): number };
+func();
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_2-expected.txt b/es2panda/test/compiler/ts/functionCall_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..118db10fb74fc583fea1cc358f0e47336e517cf8
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_2-expected.txt
@@ -0,0 +1,335 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 20
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 16
+              },
+              "end": {
+                "line": 1,
+                "column": 17
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSVoidKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 30
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 35
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 10
+            },
+            "end": {
+              "line": 5,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 20
+                },
+                "end": {
+                  "line": 5,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 16
+              },
+              "end": {
+                "line": 5,
+                "column": 17
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSStringKeyword",
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 30
+            },
+            "end": {
+              "line": 5,
+              "column": 36
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 17
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 36
+            },
+            "end": {
+              "line": 7,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func2",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 7
+                },
+                "end": {
+                  "line": 8,
+                  "column": 12
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 14
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 7
+              },
+              "end": {
+                "line": 8,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 17
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [functionCall_2.ts:8:7]
diff --git a/es2panda/test/compiler/ts/functionCall_2.ts b/es2panda/test/compiler/ts/functionCall_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1956f9b9364bdcac652413fa196617c069020f8c
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_2.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func1(a : number) : void {
+
+}
+
+function func2(a : number) : string{
+    return "foo";
+}
+func1(func2(5));
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_3-expected.txt b/es2panda/test/compiler/ts/functionCall_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ee33b73357d9072ae1f9f77d08e64c9908bad012
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_3-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 19
+                },
+                "end": {
+                  "line": 1,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSVoidKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 29
+            },
+            "end": {
+              "line": 1,
+              "column": 33
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 34
+            },
+            "end": {
+              "line": 1,
+              "column": 37
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 37
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 6
+              },
+              "end": {
+                "line": 2,
+                "column": 7
+              }
+            }
+          },
+          {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 12
+    }
+  }
+}
+TypeError: Expected 1 arguments, but got 2. [functionCall_3.ts:2:9]
diff --git a/es2panda/test/compiler/ts/functionCall_3.ts b/es2panda/test/compiler/ts/functionCall_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e652fbf6852141243d743eafeb81a8ce854129f9
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_3.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(a : number) : void { }
+func(5, 5);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_4-expected.txt b/es2panda/test/compiler/ts/functionCall_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31c7f4301f6c9c33a350da1a46d0cc0c6f7e4216
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_4-expected.txt
@@ -0,0 +1,349 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 18
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 28
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ExpressionStatement",
+              "expression": {
+                "type": "UpdateExpression",
+                "operator": "++",
+                "prefix": false,
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 6
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 8
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ConditionalExpression",
+                "test": {
+                  "type": "BinaryExpression",
+                  "operator": "<",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 0,
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 17
+                    }
+                  }
+                },
+                "consequent": {
+                  "type": "CallExpression",
+                  "callee": {
+                    "type": "Identifier",
+                    "name": "func",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "arguments": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 27
+                    }
+                  }
+                },
+                "alternate": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 31
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 35
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 6
+              },
+              "end": {
+                "line": 5,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 13
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [functionCall_4.ts:5:6]
diff --git a/es2panda/test/compiler/ts/functionCall_4.ts b/es2panda/test/compiler/ts/functionCall_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f04cae91e7b9a307402f33a2c763b0c8e66481fb
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_4.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(a: number) : number {
+    a++;
+    return a < 0 ? func(a) : a;
+}
+func("foo");
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_5-expected.txt b/es2panda/test/compiler/ts/functionCall_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5f5317661fa12c24a73b2cebc2d137788d3e82e9
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_5-expected.txt
@@ -0,0 +1,231 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 18
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 29
+                },
+                "end": {
+                  "line": 1,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 26
+              },
+              "end": {
+                "line": 1,
+                "column": 27
+              }
+            }
+          },
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 40
+                },
+                "end": {
+                  "line": 1,
+                  "column": 41
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 37
+              },
+              "end": {
+                "line": 1,
+                "column": 41
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 43
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 7
+    }
+  }
+}
+TypeError: Expected at least 2 arguments, but got 0. [functionCall_5.ts:5:1]
diff --git a/es2panda/test/compiler/ts/functionCall_5.ts b/es2panda/test/compiler/ts/functionCall_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..91c9e329b39df750f51e38e59ae4736d7a813db1
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_5.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(a: number, b: string, ...c) {
+    return 5;
+}
+
+func()
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_6-expected.txt b/es2panda/test/compiler/ts/functionCall_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0d2798ba803df9e5daa0c1239bf815045ec412b9
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_6-expected.txt
@@ -0,0 +1,145 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 18
+                },
+                "end": {
+                  "line": 1,
+                  "column": 19
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 21
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 6,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 29
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 2
+    }
+  }
+}
+TypeError: A rest parameter must be of an array type [functionCall_6.ts:1:15]
diff --git a/es2panda/test/compiler/ts/functionCall_6.ts b/es2panda/test/compiler/ts/functionCall_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49a46d6d7408646109d57c9da53f0937c1c9037c
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_6.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(...a: string) {
+    return 6;
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_7-expected.txt b/es2panda/test/compiler/ts/functionCall_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2657b2e7181e74bc28f051def462c846fb407a7a
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_7-expected.txt
@@ -0,0 +1,216 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 18
+                },
+                "end": {
+                  "line": 1,
+                  "column": 19
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 21
+                },
+                "end": {
+                  "line": 1,
+                  "column": 29
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 29
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 6,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 31
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 6
+              },
+              "end": {
+                "line": 5,
+                "column": 7
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [functionCall_7.ts:5:6]
diff --git a/es2panda/test/compiler/ts/functionCall_7.ts b/es2panda/test/compiler/ts/functionCall_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a440023debaf1471909b129e95ea31034be10640
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_7.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(...a: string[]) {
+    return 6;
+}
+
+func(2);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_8-expected.txt b/es2panda/test/compiler/ts/functionCall_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..69513e1736f3d41876969d93da3fbf69fd1221a2
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_8-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 19
+                },
+                "end": {
+                  "line": 1,
+                  "column": 25
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 30
+                },
+                "end": {
+                  "line": 1,
+                  "column": 31
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 39
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 33
+                },
+                "end": {
+                  "line": 1,
+                  "column": 41
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 27
+              },
+              "end": {
+                "line": 1,
+                "column": 41
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 43
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 6
+              },
+              "end": {
+                "line": 4,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 12
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [functionCall_8.ts:4:6]
diff --git a/es2panda/test/compiler/ts/functionCall_8.ts b/es2panda/test/compiler/ts/functionCall_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5409115cc3aa817cc1263a7ee67f8cb0d10c5502
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_8.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(a?: number, ...c: string[]) {
+}
+
+func("bar")
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionCall_9-expected.txt b/es2panda/test/compiler/ts/functionCall_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3085dfee84863cf350c4193a689a940b6636771b
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_9-expected.txt
@@ -0,0 +1,232 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 18
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 29
+                },
+                "end": {
+                  "line": 1,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 26
+              },
+              "end": {
+                "line": 1,
+                "column": 27
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 47
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 41
+                },
+                "end": {
+                  "line": 1,
+                  "column": 49
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 37
+              },
+              "end": {
+                "line": 1,
+                "column": 38
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 51
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 5
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 6
+              },
+              "end": {
+                "line": 5,
+                "column": 7
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: Expected 2-3 arguments, but got 1 [functionCall_9.ts:5:1]
diff --git a/es2panda/test/compiler/ts/functionCall_9.ts b/es2panda/test/compiler/ts/functionCall_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..918f8978053aa859c4222b5cd02c88a6d790b6ad
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionCall_9.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(a: number, b: string, c?: number[]) {
+
+}
+
+func(1);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionOverload1-expected.txt b/es2panda/test/compiler/ts/functionOverload1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4b24d4cbd619359883eafbed9139ae31dc492f9e
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload1-expected.txt
@@ -0,0 +1,665 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "y",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 41
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 44
+            },
+            "end": {
+              "line": 1,
+              "column": 50
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 51
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "y",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 41
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 41
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 14
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 44
+            },
+            "end": {
+              "line": 2,
+              "column": 50
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 51
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 28
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 37
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 41
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "x",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 14
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 14
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 18
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 18
+    }
+  }
+}
+TypeError: No overload matches this call. [functionOverload1.ts:7:1]
diff --git a/es2panda/test/compiler/ts/functionOverload1.ts b/es2panda/test/compiler/ts/functionOverload1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..456c8ffce6b90d00f1fe0dfb10a640e4205241ab
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload1.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a: { x: number, y: string }): number;
+function foo(a: { x: string, y: number }): number;
+function foo(a: { x: number | string }) {
+    return 2;
+}
+
+foo({ x: true });
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionOverload2-expected.txt b/es2panda/test/compiler/ts/functionOverload2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b35ef4e6d717e5675819c837e2d03d0bbe2fae27
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload2-expected.txt
@@ -0,0 +1,784 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 28
+                },
+                "end": {
+                  "line": 1,
+                  "column": 34
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 38
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 46
+                },
+                "end": {
+                  "line": 1,
+                  "column": 53
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 37
+            },
+            "end": {
+              "line": 1,
+              "column": 53
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 54
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 54
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 14
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 28
+                },
+                "end": {
+                  "line": 2,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 25
+              },
+              "end": {
+                "line": 2,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 39
+                },
+                "end": {
+                  "line": 2,
+                  "column": 46
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 47
+                },
+                "end": {
+                  "line": 2,
+                  "column": 54
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 38
+            },
+            "end": {
+              "line": 2,
+              "column": 54
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 55
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 55
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 28
+                },
+                "end": {
+                  "line": 3,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 25
+              },
+              "end": {
+                "line": 3,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 39
+                },
+                "end": {
+                  "line": 3,
+                  "column": 46
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 47
+                },
+                "end": {
+                  "line": 3,
+                  "column": 54
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 38
+            },
+            "end": {
+              "line": 3,
+              "column": 54
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 55
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 55
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 10
+            },
+            "end": {
+              "line": 4,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSBigIntKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 41
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 17
+                },
+                "end": {
+                  "line": 4,
+                  "column": 41
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 14
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 53
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 56
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 46
+                },
+                "end": {
+                  "line": 4,
+                  "column": 62
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 43
+              },
+              "end": {
+                "line": 4,
+                "column": 44
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 66
+                },
+                "end": {
+                  "line": 4,
+                  "column": 73
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 74
+                },
+                "end": {
+                  "line": 4,
+                  "column": 81
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 65
+            },
+            "end": {
+              "line": 4,
+              "column": 81
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 14
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 5
+                },
+                "end": {
+                  "line": 5,
+                  "column": 23
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 82
+            },
+            "end": {
+              "line": 6,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 7
+            },
+            "end": {
+              "line": 8,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 9
+    }
+  }
+}
+TypeError: operator + cannot be applied to types { (a: number, b: string): [number, string], (a: string, b: boolean): [number, string], (a: bigint, b: boolean): [number, string] } and 5 [functionOverload2.ts:8:1]
diff --git a/es2panda/test/compiler/ts/functionOverload2.ts b/es2panda/test/compiler/ts/functionOverload2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f4405ad3a60feebbdf6a170eea79f6966c176812
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload2.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a: number, b: string): [number, string];
+function foo(a: string, b: boolean): [number, string];
+function foo(a: bigint, b: boolean): [number, string];
+function foo(a: string | number | bigint, b: boolean | string): [number, string] {
+    return [1, "foo"];
+}
+
+foo + 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionOverload3-expected.txt b/es2panda/test/compiler/ts/functionOverload3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1d4e144d9467c4aceff01b00e0b4628fd013a34c
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload3-expected.txt
@@ -0,0 +1,505 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 29
+                },
+                "end": {
+                  "line": 1,
+                  "column": 35
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 38
+            },
+            "end": {
+              "line": 1,
+              "column": 44
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 45
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 14
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 37
+                },
+                "end": {
+                  "line": 2,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 34
+              },
+              "end": {
+                "line": 2,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 48
+                },
+                "end": {
+                  "line": 2,
+                  "column": 54
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 45
+              },
+              "end": {
+                "line": 2,
+                "column": 46
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 57
+            },
+            "end": {
+              "line": 2,
+              "column": 63
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 64
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 38
+                },
+                "end": {
+                  "line": 3,
+                  "column": 44
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 34
+              },
+              "end": {
+                "line": 3,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 50
+                },
+                "end": {
+                  "line": 3,
+                  "column": 56
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 46
+              },
+              "end": {
+                "line": 3,
+                "column": 47
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 17
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 58
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 2
+    }
+  }
+}
+TypeError: This overload signature is not compatible with its implementation signature [functionOverload3.ts:3:1]
diff --git a/es2panda/test/compiler/ts/functionOverload3.ts b/es2panda/test/compiler/ts/functionOverload3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..94454fc0bff44e4c3c975c35ee241c0e6dc749c3
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload3.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a: number, b?: string): number;
+function foo(a: string | number, b: string, c: number): number;
+function foo(a: string | number, b?: string, c?: number) {
+    return "foo";
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionOverload4-expected.txt b/es2panda/test/compiler/ts/functionOverload4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..663cac93455c0879c2bc539a755dc9682541cdf4
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload4-expected.txt
@@ -0,0 +1,607 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 29
+                },
+                "end": {
+                  "line": 1,
+                  "column": 35
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 38
+            },
+            "end": {
+              "line": 1,
+              "column": 44
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 45
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 14
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 37
+                },
+                "end": {
+                  "line": 2,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 34
+              },
+              "end": {
+                "line": 2,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 48
+                },
+                "end": {
+                  "line": 2,
+                  "column": 54
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 45
+              },
+              "end": {
+                "line": 2,
+                "column": 46
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 57
+            },
+            "end": {
+              "line": 2,
+              "column": 63
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 64
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 38
+                },
+                "end": {
+                  "line": 3,
+                  "column": 44
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 34
+              },
+              "end": {
+                "line": 3,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 50
+                },
+                "end": {
+                  "line": 3,
+                  "column": 56
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 46
+              },
+              "end": {
+                "line": 3,
+                "column": 47
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 12,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 58
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 17
+                },
+                "end": {
+                  "line": 7,
+                  "column": 20
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 17
+              },
+              "end": {
+                "line": 7,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 24
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string' [functionOverload4.ts:7:5]
diff --git a/es2panda/test/compiler/ts/functionOverload4.ts b/es2panda/test/compiler/ts/functionOverload4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d9a451a293b84e462f1e4ff4abf5751d2ba31ad7
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionOverload4.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a: number, b?: string): number;
+function foo(a: string | number, b: string, c: number): number;
+function foo(a: string | number, b?: string, c?: number) {
+    return 12;
+}
+
+var a: string = foo(2);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern1-expected.txt b/es2panda/test/compiler/ts/functionWithPattern1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..49a2b4b15b66d801aa76663756a97aec4ce65243
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern1-expected.txt
@@ -0,0 +1,410 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "x",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 18
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "NumberLiteral",
+                          "value": 6,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 22
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "y",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 35
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "z",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 39
+                }
+              }
+            },
+            "right": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "x",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 45
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 46
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 53
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 57
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 58
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 3,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 42
+                },
+                "end": {
+                  "line": 1,
+                  "column": 62
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 62
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 64
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 7
+            },
+            "end": {
+              "line": 5,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: operator + cannot be applied to types ([{ x }, y, z]?: [{ x?: string; }, number, number]) => void and 5 [functionWithPattern1.ts:5:1]
diff --git a/es2panda/test/compiler/ts/functionWithPattern1.ts b/es2panda/test/compiler/ts/functionWithPattern1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..96d6a305a01d0f06ad765f69997c8785d527cc24
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern1.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo([{ x = 6 }, y = "foo", z] = [{ x: "foo" }, 2, 3]) {
+
+}
+
+foo + 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern10-expected.txt b/es2panda/test/compiler/ts/functionWithPattern10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d9ecf091d6023ebccbd4cc9c9a5c53aa05be8927
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern10-expected.txt
@@ -0,0 +1,1155 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 6,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 33
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            {
+                              "type": "Identifier",
+                              "name": "d",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 35
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 36
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 41
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 45
+                                }
+                              }
+                            },
+                            {
+                              "type": "ArrayExpression",
+                              "elements": [
+                                {
+                                  "type": "BigIntLiteral",
+                                  "value": "",
+                                  "bigint": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 48
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 50
+                                    }
+                                  }
+                                },
+                                {
+                                  "type": "StringLiteral",
+                                  "value": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 52
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 57
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 47
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 58
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 59
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "t",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 61
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 62
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ObjectExpression",
+                          "properties": [
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 67
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 68
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "NumberLiteral",
+                                "value": 3,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 70
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 71
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 71
+                                }
+                              }
+                            },
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 73
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 74
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "ObjectExpression",
+                                "properties": [
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "a",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 78
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 79
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "NumberLiteral",
+                                      "value": 2,
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 81
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 82
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 78
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 82
+                                      }
+                                    }
+                                  },
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "b",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 84
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 85
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "BigIntLiteral",
+                                      "value": "",
+                                      "bigint": "",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 87
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 89
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 84
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 89
+                                      }
+                                    }
+                                  }
+                                ],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 76
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 91
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 73
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 91
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 93
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 93
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 61
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 93
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 96
+                }
+              }
+            },
+            "right": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 100
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 105
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 107
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 109
+                    }
+                  }
+                },
+                {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 111
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 113
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 99
+                },
+                "end": {
+                  "line": 1,
+                  "column": 114
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 114
+              }
+            }
+          },
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "r",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 118
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 119
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "Identifier",
+                              "name": "r",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 123
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 124
+                                }
+                              }
+                            },
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "z",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 126
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 127
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 5,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 130
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 131
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 126
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 131
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 122
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 132
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 136
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 140
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 135
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 141
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 122
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 141
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 121
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 142
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 147
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 148
+                              }
+                            }
+                          },
+                          {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 150
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 155
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 146
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 156
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 145
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 157
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 121
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 157
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 118
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 157
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 116
+              },
+              "end": {
+                "line": 1,
+                "column": 159
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 161
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 23
+                            }
+                          }
+                        },
+                        {
+                          "type": "ArrayExpression",
+                          "elements": [],
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 27
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 28
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 28
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "t",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 31
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 34
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 34
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 36
+                  }
+                }
+              },
+              {
+                "type": "BigIntLiteral",
+                "value": "",
+                "bigint": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 40
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 41
+              }
+            }
+          },
+          {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 43
+              },
+              "end": {
+                "line": 5,
+                "column": 45
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 46
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 47
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type '{ a: number; b: { a: number; b: bigint; }; }'. [functionWithPattern10.ts:5:30]
diff --git a/es2panda/test/compiler/ts/functionWithPattern10.ts b/es2panda/test/compiler/ts/functionWithPattern10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6df8cc54ce367f2fcb5e7910df6003c0c2b23a25
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern10.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo([a = 2, { b: [c = 6, d] = [true, [5n, "foo"]], t = { a: 3, b: { a: 2, b: 5n } } }] = ["foo", {}, 4n], { r: [[r, z = 5] = [true]] = [[2, "foo"]] }) {
+
+}
+
+foo(["foo", { b: [true, []], t: 5 }, 5n], {});
diff --git a/es2panda/test/compiler/ts/functionWithPattern11-expected.txt b/es2panda/test/compiler/ts/functionWithPattern11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..023440038f80712ddbe28d6a5b4913686efc4e7b
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern11-expected.txt
@@ -0,0 +1,1248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 6,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 33
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            {
+                              "type": "Identifier",
+                              "name": "d",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 35
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 36
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 41
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 45
+                                }
+                              }
+                            },
+                            {
+                              "type": "ArrayExpression",
+                              "elements": [
+                                {
+                                  "type": "BigIntLiteral",
+                                  "value": "",
+                                  "bigint": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 48
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 50
+                                    }
+                                  }
+                                },
+                                {
+                                  "type": "StringLiteral",
+                                  "value": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 52
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 57
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 47
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 58
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 59
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "t",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 61
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 62
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ObjectExpression",
+                          "properties": [
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 67
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 68
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "NumberLiteral",
+                                "value": 3,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 70
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 71
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 71
+                                }
+                              }
+                            },
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 73
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 74
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "ObjectExpression",
+                                "properties": [
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "a",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 78
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 79
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "NumberLiteral",
+                                      "value": 2,
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 81
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 82
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 78
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 82
+                                      }
+                                    }
+                                  },
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "b",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 84
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 85
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "BigIntLiteral",
+                                      "value": "",
+                                      "bigint": "",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 87
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 89
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 84
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 89
+                                      }
+                                    }
+                                  }
+                                ],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 76
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 91
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 73
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 91
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 93
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 93
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 61
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 93
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 96
+                }
+              }
+            },
+            "right": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 100
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 105
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 107
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 109
+                    }
+                  }
+                },
+                {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 111
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 113
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 99
+                },
+                "end": {
+                  "line": 1,
+                  "column": 114
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 114
+              }
+            }
+          },
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "r",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 118
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 119
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "Identifier",
+                              "name": "r",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 123
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 124
+                                }
+                              }
+                            },
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "z",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 126
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 127
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 5,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 130
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 131
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 126
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 131
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 122
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 132
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 136
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 140
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 135
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 141
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 122
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 141
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 121
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 142
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 147
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 148
+                              }
+                            }
+                          },
+                          {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 150
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 155
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 146
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 156
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 145
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 157
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 121
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 157
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 118
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 157
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 116
+              },
+              "end": {
+                "line": 1,
+                "column": 159
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 161
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 23
+                            }
+                          }
+                        },
+                        {
+                          "type": "ArrayExpression",
+                          "elements": [],
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 27
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 28
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 28
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "t",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 31
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "ObjectExpression",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "a",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 5,
+                                "column": 35
+                              },
+                              "end": {
+                                "line": 5,
+                                "column": 36
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "NumberLiteral",
+                            "value": 1,
+                            "loc": {
+                              "start": {
+                                "line": 5,
+                                "column": 38
+                              },
+                              "end": {
+                                "line": 5,
+                                "column": 39
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 35
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 39
+                            }
+                          }
+                        },
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "z",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 5,
+                                "column": 41
+                              },
+                              "end": {
+                                "line": 5,
+                                "column": 42
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 5,
+                                "column": 44
+                              },
+                              "end": {
+                                "line": 5,
+                                "column": 49
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 41
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 49
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 51
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 51
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 53
+                  }
+                }
+              },
+              {
+                "type": "BigIntLiteral",
+                "value": "",
+                "bigint": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 57
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 58
+              }
+            }
+          },
+          {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 60
+              },
+              "end": {
+                "line": 5,
+                "column": 62
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 63
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 64
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'z' does not exist in type '{ a: number; b: { a: number; b: bigint; }; }' [functionWithPattern11.ts:5:41]
diff --git a/es2panda/test/compiler/ts/functionWithPattern11.ts b/es2panda/test/compiler/ts/functionWithPattern11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d750ca762054e95e91e23a740b7a253d9035c280
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern11.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo([a = 2, { b: [c = 6, d] = [true, [5n, "foo"]], t = { a: 3, b: { a: 2, b: 5n } } }] = ["foo", {}, 4n], { r: [[r, z = 5] = [true]] = [[2, "foo"]] }) {
+
+}
+
+foo(["foo", { b: [true, []], t: { a: 1, z: "foo" } }, 5n], {});
diff --git a/es2panda/test/compiler/ts/functionWithPattern12-expected.txt b/es2panda/test/compiler/ts/functionWithPattern12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6936371ba43772e23ae5dbd951f35f98bd1db3fe
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern12-expected.txt
@@ -0,0 +1,1110 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 6,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 33
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            {
+                              "type": "Identifier",
+                              "name": "d",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 35
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 36
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 41
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 45
+                                }
+                              }
+                            },
+                            {
+                              "type": "ArrayExpression",
+                              "elements": [
+                                {
+                                  "type": "BigIntLiteral",
+                                  "value": "",
+                                  "bigint": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 48
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 50
+                                    }
+                                  }
+                                },
+                                {
+                                  "type": "StringLiteral",
+                                  "value": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 52
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 57
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 47
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 58
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 59
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "t",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 61
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 62
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ObjectExpression",
+                          "properties": [
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 67
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 68
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "NumberLiteral",
+                                "value": 3,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 70
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 71
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 71
+                                }
+                              }
+                            },
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 73
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 74
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "ObjectExpression",
+                                "properties": [
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "a",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 78
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 79
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "NumberLiteral",
+                                      "value": 2,
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 81
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 82
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 78
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 82
+                                      }
+                                    }
+                                  },
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "b",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 84
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 85
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "BigIntLiteral",
+                                      "value": "",
+                                      "bigint": "",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 87
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 89
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 84
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 89
+                                      }
+                                    }
+                                  }
+                                ],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 76
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 91
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 73
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 91
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 93
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 93
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 61
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 93
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 96
+                }
+              }
+            },
+            "right": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 100
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 105
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 107
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 109
+                    }
+                  }
+                },
+                {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 111
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 113
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 99
+                },
+                "end": {
+                  "line": 1,
+                  "column": 114
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 114
+              }
+            }
+          },
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "r",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 118
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 119
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "Identifier",
+                              "name": "r",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 123
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 124
+                                }
+                              }
+                            },
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "z",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 126
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 127
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 5,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 130
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 131
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 126
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 131
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 122
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 132
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 136
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 140
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 135
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 141
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 122
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 141
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 121
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 142
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 147
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 148
+                              }
+                            }
+                          },
+                          {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 150
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 155
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 146
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 156
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 145
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 157
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 121
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 157
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 118
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 157
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 116
+              },
+              "end": {
+                "line": 1,
+                "column": 159
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 161
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 15
+                  }
+                }
+              },
+              {
+                "type": "BigIntLiteral",
+                "value": "",
+                "bigint": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 20
+              }
+            }
+          },
+          {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "r",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 25
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 35
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 36
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 36
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 22
+              },
+              "end": {
+                "line": 5,
+                "column": 38
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 39
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 40
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [functionWithPattern12.ts:5:29]
diff --git a/es2panda/test/compiler/ts/functionWithPattern12.ts b/es2panda/test/compiler/ts/functionWithPattern12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..76cec574f5feee4578c31057f66596ba7af5f56a
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern12.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo([a = 2, { b: [c = 6, d] = [true, [5n, "foo"]], t = { a: 3, b: { a: 2, b: 5n } } }] = ["foo", {}, 4n], { r: [[r, z = 5] = [true]] = [[2, "foo"]] }) {
+
+}
+
+foo(["foo", {}, 5n], { r: [["foo"]] });
diff --git a/es2panda/test/compiler/ts/functionWithPattern2-expected.txt b/es2panda/test/compiler/ts/functionWithPattern2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0b42d6518672e97e930cd0aa7c3c8342fd57e41a
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern2-expected.txt
@@ -0,0 +1,369 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ObjectPattern",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "NumberLiteral",
+                      "value": 6,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "y",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "y",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 34
+                }
+              }
+            },
+            "right": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 47
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 37
+                },
+                "end": {
+                  "line": 1,
+                  "column": 49
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 49
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 51
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 7
+            },
+            "end": {
+              "line": 5,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: operator + cannot be applied to types ({ x, y }?: { x?: string; y?: string; }) => void and 5 [functionWithPattern2.ts:5:1]
diff --git a/es2panda/test/compiler/ts/functionWithPattern2.ts b/es2panda/test/compiler/ts/functionWithPattern2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f34e03a23c5f8b71fd8290f7811cb893d94bf2ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern2.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo({ x = 6, y = "foo" } = { x: "foo" }) {
+
+}
+
+foo + 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern3-expected.txt b/es2panda/test/compiler/ts/functionWithPattern3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aaaf2c5919dce4296da2cac0ab05502aaa964803
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern3-expected.txt
@@ -0,0 +1,510 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "x",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "asd",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "asd",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 26
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "y",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 29
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 33
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 34
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 33
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 6,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 37
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 38
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 33
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 38
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 33
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "r",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 41
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "r",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 44
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 49
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 49
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 49
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 51
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 56
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 57
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 59
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 56
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 64
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 66
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 66
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 66
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 68
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 70
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 7
+            },
+            "end": {
+              "line": 5,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: operator + cannot be applied to types ({ x: { asd }, y: { t, r } }: { x: { asd: any; }; y?: { t?: string; r?: string; }; }) => void and 5 [functionWithPattern3.ts:5:1]
diff --git a/es2panda/test/compiler/ts/functionWithPattern3.ts b/es2panda/test/compiler/ts/functionWithPattern3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8318c935d74f3871137362e9046bd32c2343d15e
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern3.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo({ x: { asd }, y: { t = 6, r = "foo" } = { t: "foo" } }) {
+
+}
+
+foo + 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern4-expected.txt b/es2panda/test/compiler/ts/functionWithPattern4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5ac11c8f00a1cf35ce199d1dd4386499f73fd32a
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern4-expected.txt
@@ -0,0 +1,679 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ObjectPattern",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ObjectPattern",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": true,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "AssignmentPattern",
+                            "left": {
+                              "type": "Identifier",
+                              "name": "t",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 33
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 33
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ObjectExpression",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 43
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 44
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 44
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "e",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 52
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 53
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "ObjectExpression",
+                            "properties": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 56
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 58
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 52
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 58
+                            }
+                          }
+                        },
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "f",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 60
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 61
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 6,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 65
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 65
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "NumberLiteral",
+                          "value": 3,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 70
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 71
+                            }
+                          }
+                        },
+                        {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 74
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 79
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 81
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 86
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 73
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 87
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 69
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 88
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 88
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 88
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 90
+                }
+              }
+            },
+            "right": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 95
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 96
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 98
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 102
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 95
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 102
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 93
+                },
+                "end": {
+                  "line": 1,
+                  "column": 104
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 104
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 106
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 7
+            },
+            "end": {
+              "line": 5,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: operator + cannot be applied to types ({ a, b: { t }, d: [e, f] }?: { a: boolean; b?: { t?: number; }; d?: [number, string[]]; }) => void and 5 [functionWithPattern4.ts:5:1]
diff --git a/es2panda/test/compiler/ts/functionWithPattern4.ts b/es2panda/test/compiler/ts/functionWithPattern4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae9c225c58bed146d274762521687dfc0f91214a
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern4.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo({ a, b: { t = "foo" } = { t: 3 }, d: [e = {}, f = 6] = [3, ["foo", "bar"]] } = { a: true }) {
+
+}
+
+foo + 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern5-expected.txt b/es2panda/test/compiler/ts/functionWithPattern5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..84c17a330f9e6c55e0dc6de0abb37b373f2b558e
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern5-expected.txt
@@ -0,0 +1,728 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ObjectPattern",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ObjectPattern",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": true,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "AssignmentPattern",
+                            "left": {
+                              "type": "Identifier",
+                              "name": "t",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 33
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 33
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ObjectExpression",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 43
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 44
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 44
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "e",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 52
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 53
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "ObjectExpression",
+                            "properties": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 56
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 58
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 52
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 58
+                            }
+                          }
+                        },
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "f",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 60
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 61
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 6,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 65
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 65
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "NumberLiteral",
+                          "value": 3,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 70
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 71
+                            }
+                          }
+                        },
+                        {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 74
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 79
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 81
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 86
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 73
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 87
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 69
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 88
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 88
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 88
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 90
+                }
+              }
+            },
+            "right": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 95
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 96
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 98
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 102
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 95
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 102
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 93
+                },
+                "end": {
+                  "line": 1,
+                  "column": 104
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 104
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 106
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 11
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 15
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [functionWithPattern5.ts:5:7]
diff --git a/es2panda/test/compiler/ts/functionWithPattern5.ts b/es2panda/test/compiler/ts/functionWithPattern5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9438a0d0abff6e58cd49dd2ba0552ce36485ee8c
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern5.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo({ a, b: { t = "foo" } = { t: 3 }, d: [e = {}, f = 6] = [3, ["foo", "bar"]] } = { a: true }) {
+
+}
+
+foo({ a: 5 });
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern6-expected.txt b/es2panda/test/compiler/ts/functionWithPattern6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..00edda28840ca884ef089c79ec555e500bb9574a
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern6-expected.txt
@@ -0,0 +1,821 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ObjectPattern",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ObjectPattern",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": true,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "AssignmentPattern",
+                            "left": {
+                              "type": "Identifier",
+                              "name": "t",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 33
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 33
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ObjectExpression",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 43
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 44
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 44
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "e",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 52
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 53
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "ObjectExpression",
+                            "properties": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 56
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 58
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 52
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 58
+                            }
+                          }
+                        },
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "f",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 60
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 61
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 6,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 65
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 65
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "NumberLiteral",
+                          "value": 3,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 70
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 71
+                            }
+                          }
+                        },
+                        {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 74
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 79
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 81
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 86
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 73
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 87
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 69
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 88
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 88
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 88
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 90
+                }
+              }
+            },
+            "right": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 95
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 96
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 98
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 102
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 95
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 102
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 93
+                },
+                "end": {
+                  "line": 1,
+                  "column": 104
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 104
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 106
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": false,
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 15
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 15
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 18
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "r",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 31
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 31
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 35
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 36
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 37
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 37
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'r' does not exist in type '{ t?: number; }' [functionWithPattern6.ts:5:22]
diff --git a/es2panda/test/compiler/ts/functionWithPattern6.ts b/es2panda/test/compiler/ts/functionWithPattern6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7e5c79d36a203b30603d77c80aba998e7dde7f6d
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern6.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo({ a, b: { t = "foo" } = { t: 3 }, d: [e = {}, f = 6] = [3, ["foo", "bar"]] } = { a: true }) {
+
+}
+
+foo({ a: false, b: { r: "foo " } });
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern7-expected.txt b/es2panda/test/compiler/ts/functionWithPattern7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..749c8a0b986e6e3b5f732dfbd9f40b059a91218d
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern7-expected.txt
@@ -0,0 +1,850 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ObjectPattern",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ObjectPattern",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": true,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "AssignmentPattern",
+                            "left": {
+                              "type": "Identifier",
+                              "name": "t",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 33
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 33
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ObjectExpression",
+                      "properties": [
+                        {
+                          "type": "Property",
+                          "method": false,
+                          "shorthand": false,
+                          "computed": false,
+                          "key": {
+                            "type": "Identifier",
+                            "name": "t",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "value": {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 43
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 44
+                              }
+                            }
+                          },
+                          "kind": "init",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 44
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "e",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 52
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 53
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "ObjectExpression",
+                            "properties": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 56
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 58
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 52
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 58
+                            }
+                          }
+                        },
+                        {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "f",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 60
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 61
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 6,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 65
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 65
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 66
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "NumberLiteral",
+                          "value": 3,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 70
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 71
+                            }
+                          }
+                        },
+                        {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 74
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 79
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 81
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 86
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 73
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 87
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 69
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 88
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 88
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 88
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 90
+                }
+              }
+            },
+            "right": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 95
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 96
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 98
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 102
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 95
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 102
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 93
+                },
+                "end": {
+                  "line": 1,
+                  "column": 104
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 104
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 106
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": false,
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 15
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 15
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 18
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 22
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 25
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 2,
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 29
+                        }
+                      }
+                    },
+                    {
+                      "type": "BigIntLiteral",
+                      "value": "",
+                      "bigint": "",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 33
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 34
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 34
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 37
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 38
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 38
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'string[]'. [functionWithPattern7.ts:5:31]
diff --git a/es2panda/test/compiler/ts/functionWithPattern7.ts b/es2panda/test/compiler/ts/functionWithPattern7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c685d35349eeb1793232a16805e29e1827d7625
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern7.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo({ a, b: { t = "foo" } = { t: 3 }, d: [e = {}, f = 6] = [3, ["foo", "bar"]] } = { a: true }) {
+
+}
+
+foo({ a: false, b: {}, d: [2, 5n] });
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern8-expected.txt b/es2panda/test/compiler/ts/functionWithPattern8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a49564e30312f6c17e2eed8d0dd74f0aa7c1dd2f
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern8-expected.txt
@@ -0,0 +1,973 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 6,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 33
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            {
+                              "type": "Identifier",
+                              "name": "d",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 35
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 36
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 41
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 45
+                                }
+                              }
+                            },
+                            {
+                              "type": "ArrayExpression",
+                              "elements": [
+                                {
+                                  "type": "BigIntLiteral",
+                                  "value": "",
+                                  "bigint": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 48
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 50
+                                    }
+                                  }
+                                },
+                                {
+                                  "type": "StringLiteral",
+                                  "value": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 52
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 57
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 47
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 58
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 59
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "t",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 61
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 62
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ObjectExpression",
+                          "properties": [
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 67
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 68
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "NumberLiteral",
+                                "value": 3,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 70
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 71
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 71
+                                }
+                              }
+                            },
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 73
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 74
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "ObjectExpression",
+                                "properties": [
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "a",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 78
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 79
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "NumberLiteral",
+                                      "value": 2,
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 81
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 82
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 78
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 82
+                                      }
+                                    }
+                                  },
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "b",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 84
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 85
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "BigIntLiteral",
+                                      "value": "",
+                                      "bigint": "",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 87
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 89
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 84
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 89
+                                      }
+                                    }
+                                  }
+                                ],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 76
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 91
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 73
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 91
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 93
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 93
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 61
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 93
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 96
+                }
+              }
+            },
+            "right": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 100
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 105
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 107
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 109
+                    }
+                  }
+                },
+                {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 111
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 113
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 99
+                },
+                "end": {
+                  "line": 1,
+                  "column": 114
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 114
+              }
+            }
+          },
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "r",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 118
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 119
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "Identifier",
+                              "name": "r",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 123
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 124
+                                }
+                              }
+                            },
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "z",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 126
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 127
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 5,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 130
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 131
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 126
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 131
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 122
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 132
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 136
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 140
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 135
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 141
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 122
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 141
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 121
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 142
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 147
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 148
+                              }
+                            }
+                          },
+                          {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 150
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 155
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 146
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 156
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 145
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 157
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 121
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 157
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 118
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 157
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 116
+              },
+              "end": {
+                "line": 1,
+                "column": 159
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 161
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 7
+            },
+            "end": {
+              "line": 5,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: operator + cannot be applied to types ([a, { b: [c, d], t }]?: [string, { b?: [boolean, (bigint | string)[]]; t?: { a: number; b: { a: number; b: bigint; }; }; }, bigint], { r: [[r, z]] }: { r?: [[number, string]]; }) => void and 5 [functionWithPattern8.ts:5:1]
diff --git a/es2panda/test/compiler/ts/functionWithPattern8.ts b/es2panda/test/compiler/ts/functionWithPattern8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ddf96eb4d653682003e4edfcb857843e2b13e65d
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern8.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo([a = 2, { b: [c = 6, d] = [true, [5n, "foo"]], t = { a: 3, b: { a: 2, b: 5n } } }] = ["foo", {}, 4n], { r: [[r, z = 5] = [true]] = [[2, "foo"]] }) {
+
+}
+
+foo + 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/functionWithPattern9-expected.txt b/es2panda/test/compiler/ts/functionWithPattern9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..47affdb43cc36899b29601f8fb2da976d57b942d
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern9-expected.txt
@@ -0,0 +1,1080 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 6,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 33
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 33
+                                }
+                              }
+                            },
+                            {
+                              "type": "Identifier",
+                              "name": "d",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 35
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 36
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 41
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 45
+                                }
+                              }
+                            },
+                            {
+                              "type": "ArrayExpression",
+                              "elements": [
+                                {
+                                  "type": "BigIntLiteral",
+                                  "value": "",
+                                  "bigint": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 48
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 50
+                                    }
+                                  }
+                                },
+                                {
+                                  "type": "StringLiteral",
+                                  "value": "",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 52
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 57
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 47
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 58
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 59
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "t",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 61
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 62
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ObjectExpression",
+                          "properties": [
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 67
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 68
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "NumberLiteral",
+                                "value": 3,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 70
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 71
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 71
+                                }
+                              }
+                            },
+                            {
+                              "type": "Property",
+                              "method": false,
+                              "shorthand": false,
+                              "computed": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 73
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 74
+                                  }
+                                }
+                              },
+                              "value": {
+                                "type": "ObjectExpression",
+                                "properties": [
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "a",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 78
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 79
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "NumberLiteral",
+                                      "value": 2,
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 81
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 82
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 78
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 82
+                                      }
+                                    }
+                                  },
+                                  {
+                                    "type": "Property",
+                                    "method": false,
+                                    "shorthand": false,
+                                    "computed": false,
+                                    "key": {
+                                      "type": "Identifier",
+                                      "name": "b",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 84
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 85
+                                        }
+                                      }
+                                    },
+                                    "value": {
+                                      "type": "BigIntLiteral",
+                                      "value": "",
+                                      "bigint": "",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 87
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 89
+                                        }
+                                      }
+                                    },
+                                    "kind": "init",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 84
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 89
+                                      }
+                                    }
+                                  }
+                                ],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 76
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 91
+                                  }
+                                }
+                              },
+                              "kind": "init",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 73
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 91
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 93
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 93
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 61
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 93
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 14
+                },
+                "end": {
+                  "line": 1,
+                  "column": 96
+                }
+              }
+            },
+            "right": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 100
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 105
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 107
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 109
+                    }
+                  }
+                },
+                {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 111
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 113
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 99
+                },
+                "end": {
+                  "line": 1,
+                  "column": 114
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 114
+              }
+            }
+          },
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "r",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 118
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 119
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "Identifier",
+                              "name": "r",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 123
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 124
+                                }
+                              }
+                            },
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "z",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 126
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 127
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 5,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 130
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 131
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 126
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 131
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 122
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 132
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 136
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 140
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 135
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 141
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 122
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 141
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 121
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 142
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 147
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 148
+                              }
+                            }
+                          },
+                          {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 150
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 155
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 146
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 156
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 145
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 157
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 121
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 157
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 118
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 157
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 116
+              },
+              "end": {
+                "line": 1,
+                "column": 159
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 161
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "ArrayExpression",
+                      "elements": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 20
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BigIntLiteral",
+                "value": "",
+                "bigint": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 26
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 27
+              }
+            }
+          },
+          {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 29
+              },
+              "end": {
+                "line": 5,
+                "column": 31
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 32
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 33
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '[]' is not assignable to type '[boolean, (bigint | string)[]]'. [functionWithPattern9.ts:5:15]
diff --git a/es2panda/test/compiler/ts/functionWithPattern9.ts b/es2panda/test/compiler/ts/functionWithPattern9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0334dba413c8543073c72316d93e20f4772d8c0d
--- /dev/null
+++ b/es2panda/test/compiler/ts/functionWithPattern9.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo([a = 2, { b: [c = 6, d] = [true, [5n, "foo"]], t = { a: 3, b: { a: 2, b: 5n } } }] = ["foo", {}, 4n], { r: [[r, z = 5] = [true]] = [[2, "foo"]] }) {
+
+}
+
+foo(["foo", { b: [] }, 5n], {});
diff --git a/es2panda/test/compiler/ts/function_declaration_1-expected.txt b/es2panda/test/compiler/ts/function_declaration_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c36842be5f8f683c5e988b26ea391986a00caf7e
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_1-expected.txt
@@ -0,0 +1,88 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSStringKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: A function whose declared type is neither 'void' nor 'any' must return a value. [function_declaration_1.ts:1:17]
diff --git a/es2panda/test/compiler/ts/function_declaration_1.ts b/es2panda/test/compiler/ts/function_declaration_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a7e93ffc6b7cedec2188c452e4b1d29029bf626b
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_1.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): string {
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_10-expected.txt b/es2panda/test/compiler/ts/function_declaration_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..72d7060f9eca4072e3a405b45811397613261cd3
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_10-expected.txt
@@ -0,0 +1,116 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 25
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'boolean'. [function_declaration_10.ts:2:1]
diff --git a/es2panda/test/compiler/ts/function_declaration_10.ts b/es2panda/test/compiler/ts/function_declaration_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4c3a53bd891f0b4fcb7c4a6c87669156beabc3ee
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): boolean {
+return 5;
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_11-expected.txt b/es2panda/test/compiler/ts/function_declaration_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e9034d7fda057fb58d1c14140a5786666f2b9915
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_11-expected.txt
@@ -0,0 +1,88 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSNeverKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 22
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 23
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: A function returning 'never' cannot have a reachable end point. [function_declaration_11.ts:1:17]
diff --git a/es2panda/test/compiler/ts/function_declaration_11.ts b/es2panda/test/compiler/ts/function_declaration_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..271030374cb24b3e5d25d1cc504d844b6430ba42
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_11.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): never {
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_2-expected.txt b/es2panda/test/compiler/ts/function_declaration_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65674f08ba9f4ebab1d0b114b6217dda48530354
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_2-expected.txt
@@ -0,0 +1,116 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSStringKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'string'. [function_declaration_2.ts:2:1]
diff --git a/es2panda/test/compiler/ts/function_declaration_2.ts b/es2panda/test/compiler/ts/function_declaration_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2a0e30a32f82defb0d9767c2d02d4bce31bb271a
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): string {
+return 5;
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_3-expected.txt b/es2panda/test/compiler/ts/function_declaration_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cd2f3a3ad686370ed3a25b3016688e9fa1107b63
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_3-expected.txt
@@ -0,0 +1,116 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSStringKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'false' is not assignable to type 'string'. [function_declaration_3.ts:2:1]
diff --git a/es2panda/test/compiler/ts/function_declaration_3.ts b/es2panda/test/compiler/ts/function_declaration_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0b5b86c08c365ba316f25bcbbbae2547764c0d1
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): string {
+return false;
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_4-expected.txt b/es2panda/test/compiler/ts/function_declaration_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..642fc3a063f19eafd867832d9feac7220df60801
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_4-expected.txt
@@ -0,0 +1,88 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: A function whose declared type is neither 'void' nor 'any' must return a value. [function_declaration_4.ts:1:17]
diff --git a/es2panda/test/compiler/ts/function_declaration_4.ts b/es2panda/test/compiler/ts/function_declaration_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..09a3db65f4f2e68d666b34b6bfa697cad6903642
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_4.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): number {
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_5-expected.txt b/es2panda/test/compiler/ts/function_declaration_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b8b73b01c38b575b299a7a374991ad4c5886a1dd
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_5-expected.txt
@@ -0,0 +1,116 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'false' is not assignable to type 'number'. [function_declaration_5.ts:2:1]
diff --git a/es2panda/test/compiler/ts/function_declaration_5.ts b/es2panda/test/compiler/ts/function_declaration_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ffaaa483830bd1c8b4717f5e85255fd22b686c35
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): number {
+return false;
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_6-expected.txt b/es2panda/test/compiler/ts/function_declaration_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c3021b79480b87363af38ffd743f03d7adef924c
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_6-expected.txt
@@ -0,0 +1,88 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSBigIntKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: A function whose declared type is neither 'void' nor 'any' must return a value. [function_declaration_6.ts:1:17]
diff --git a/es2panda/test/compiler/ts/function_declaration_6.ts b/es2panda/test/compiler/ts/function_declaration_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8f29170dd826a41c573e27a1cf8a3029774cdd67
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): bigint {
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_7-expected.txt b/es2panda/test/compiler/ts/function_declaration_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e470c9e02873ab13304ad711cd7a08845e7caf2f
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_7-expected.txt
@@ -0,0 +1,116 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSBigIntKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [function_declaration_7.ts:2:1]
diff --git a/es2panda/test/compiler/ts/function_declaration_7.ts b/es2panda/test/compiler/ts/function_declaration_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..34da6ae45755b927d8b2cf51eeedf6a75a7f03bc
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): bigint {
+return 5;
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_8-expected.txt b/es2panda/test/compiler/ts/function_declaration_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..88e30610083583a0922c7e52b2bfe9d677aa7fe4
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_8-expected.txt
@@ -0,0 +1,116 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSBigIntKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 24
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'false' is not assignable to type 'bigint'. [function_declaration_8.ts:2:1]
diff --git a/es2panda/test/compiler/ts/function_declaration_8.ts b/es2panda/test/compiler/ts/function_declaration_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0b253914537a04d99ab51600273f5e38b6831756
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): bigint {
+return false;
+}
diff --git a/es2panda/test/compiler/ts/function_declaration_9-expected.txt b/es2panda/test/compiler/ts/function_declaration_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1d502b427df2f8825f910731e63592918fc919bc
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_9-expected.txt
@@ -0,0 +1,88 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 17
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 25
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: A function whose declared type is neither 'void' nor 'any' must return a value. [function_declaration_9.ts:1:17]
diff --git a/es2panda/test/compiler/ts/function_declaration_9.ts b/es2panda/test/compiler/ts/function_declaration_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7d0ea412c7ff3c928929adb5a09256c3518d1be0
--- /dev/null
+++ b/es2panda/test/compiler/ts/function_declaration_9.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(): boolean {
+}
diff --git a/es2panda/test/compiler/ts/generic_interface-expected.txt b/es2panda/test/compiler/ts/generic_interface-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..98b63cb10ac58d4cbb808dac3d2dafd3b3e04ed2
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_interface-expected.txt
@@ -0,0 +1,3304 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 25
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "R",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 13
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "default": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 13
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 12
+          },
+          "end": {
+            "line": 1,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var1",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "R",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 12
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 11
+                },
+                "end": {
+                  "line": 5,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 1
+              },
+              "end": {
+                "line": 6,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 6
+              },
+              "end": {
+                "line": 6,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 10
+            },
+            "end": {
+              "line": 6,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var2",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "R",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 11
+                },
+                "end": {
+                  "line": 8,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 1
+              },
+              "end": {
+                "line": 9,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 6
+              },
+              "end": {
+                "line": 9,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 1
+            },
+            "end": {
+              "line": 9,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 10
+            },
+            "end": {
+              "line": 9,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 1
+          },
+          "end": {
+            "line": 9,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 5
+                },
+                "end": {
+                  "line": 12,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "Z",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 9
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "W",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 13
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 8
+                },
+                "end": {
+                  "line": 12,
+                  "column": 13
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 14
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 29
+          },
+          "end": {
+            "line": 13,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "U",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 11
+          },
+          "end": {
+            "line": 11,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "R",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 27
+              },
+              "end": {
+                "line": 11,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 29
+            },
+            "end": {
+              "line": 11,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "Z",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 13
+                },
+                "end": {
+                  "line": 11,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 13
+              },
+              "end": {
+                "line": 11,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "W",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 16
+                },
+                "end": {
+                  "line": 11,
+                  "column": 17
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 16
+              },
+              "end": {
+                "line": 11,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 12
+          },
+          "end": {
+            "line": 11,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var3",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "U",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 20
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 28
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 29
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 11
+                },
+                "end": {
+                  "line": 15,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 15,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 5
+            },
+            "end": {
+              "line": 15,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 1
+              },
+              "end": {
+                "line": 16,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 6
+              },
+              "end": {
+                "line": 16,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 1
+            },
+            "end": {
+              "line": 16,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 10
+            },
+            "end": {
+              "line": 16,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 1
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 1
+              },
+              "end": {
+                "line": 17,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 6
+              },
+              "end": {
+                "line": 17,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": true,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 10
+            },
+            "end": {
+              "line": 17,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 1
+              },
+              "end": {
+                "line": 18,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 6
+              },
+              "end": {
+                "line": 18,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 32,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 10
+            },
+            "end": {
+              "line": 18,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 5
+                },
+                "end": {
+                  "line": 21,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "T",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 9
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 8
+                },
+                "end": {
+                  "line": 21,
+                  "column": 11
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 25
+          },
+          "end": {
+            "line": 22,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "V",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 11
+          },
+          "end": {
+            "line": 20,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 13
+                },
+                "end": {
+                  "line": 20,
+                  "column": 14
+                }
+              }
+            },
+            "default": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 13
+              },
+              "end": {
+                "line": 20,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 12
+          },
+          "end": {
+            "line": 20,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 5
+                },
+                "end": {
+                  "line": 25,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 26,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 13
+          },
+          "end": {
+            "line": 26,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "V",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 11
+          },
+          "end": {
+            "line": 24,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var4",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "V",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 12
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 11
+                },
+                "end": {
+                  "line": 28,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 5
+            },
+            "end": {
+              "line": 28,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var4",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 1
+              },
+              "end": {
+                "line": 29,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 6
+              },
+              "end": {
+                "line": 29,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 1
+            },
+            "end": {
+              "line": 29,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 11
+                },
+                "end": {
+                  "line": 29,
+                  "column": 12
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 14
+                },
+                "end": {
+                  "line": 29,
+                  "column": 15
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 3,
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 17
+                },
+                "end": {
+                  "line": 29,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 10
+            },
+            "end": {
+              "line": 29,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var4",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 1
+              },
+              "end": {
+                "line": 30,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 6
+              },
+              "end": {
+                "line": 30,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 1
+            },
+            "end": {
+              "line": 30,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 11
+                },
+                "end": {
+                  "line": 30,
+                  "column": 16
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 18
+                },
+                "end": {
+                  "line": 30,
+                  "column": 23
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 10
+            },
+            "end": {
+              "line": 30,
+              "column": 24
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 1
+          },
+          "end": {
+            "line": 30,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 5
+                },
+                "end": {
+                  "line": 33,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "E",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 8
+                },
+                "end": {
+                  "line": 33,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 5
+                },
+                "end": {
+                  "line": 34,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "F",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 8
+                },
+                "end": {
+                  "line": 34,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 5
+              },
+              "end": {
+                "line": 34,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 46
+          },
+          "end": {
+            "line": 35,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 11
+          },
+          "end": {
+            "line": 32,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "E",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 13
+                },
+                "end": {
+                  "line": 32,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 13
+              },
+              "end": {
+                "line": 32,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "F",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 16
+                },
+                "end": {
+                  "line": 32,
+                  "column": 17
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 20
+                },
+                "end": {
+                  "line": 32,
+                  "column": 44
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 16
+              },
+              "end": {
+                "line": 32,
+                "column": 45
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 12
+          },
+          "end": {
+            "line": 32,
+            "column": 45
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var5",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "C",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 37,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 37,
+                            "column": 21
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 37,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 37,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 11
+                },
+                "end": {
+                  "line": 37,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 5
+              },
+              "end": {
+                "line": 37,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 5
+            },
+            "end": {
+              "line": 37,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var5",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 1
+              },
+              "end": {
+                "line": 38,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 6
+              },
+              "end": {
+                "line": 38,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 1
+            },
+            "end": {
+              "line": 38,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 11
+                },
+                "end": {
+                  "line": 38,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 10
+            },
+            "end": {
+              "line": 38,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 1
+          },
+          "end": {
+            "line": 38,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "var5",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 1
+              },
+              "end": {
+                "line": 39,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 6
+              },
+              "end": {
+                "line": 39,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 39,
+              "column": 1
+            },
+            "end": {
+              "line": 39,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 13
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 12
+                },
+                "end": {
+                  "line": 39,
+                  "column": 16
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 19
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 26
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 18
+                },
+                "end": {
+                  "line": 39,
+                  "column": 26
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 39,
+              "column": 10
+            },
+            "end": {
+              "line": 39,
+              "column": 28
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 39,
+            "column": 1
+          },
+          "end": {
+            "line": 39,
+            "column": 28
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 39,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "aa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 5
+                },
+                "end": {
+                  "line": 42,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 9
+                },
+                "end": {
+                  "line": 42,
+                  "column": 10
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 5
+              },
+              "end": {
+                "line": 43,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 16
+          },
+          "end": {
+            "line": 43,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 11
+          },
+          "end": {
+            "line": 41,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 13
+                },
+                "end": {
+                  "line": 41,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 13
+              },
+              "end": {
+                "line": 41,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 12
+          },
+          "end": {
+            "line": 41,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 43,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "aa",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 46,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 47,
+                      "column": 2
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 8
+                },
+                "end": {
+                  "line": 47,
+                  "column": 2
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 5
+            },
+            "end": {
+              "line": 45,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 45,
+          "column": 1
+        },
+        "end": {
+          "line": 45,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 49,
+            "column": 51
+          },
+          "end": {
+            "line": 50,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 49,
+            "column": 11
+          },
+          "end": {
+            "line": 49,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 13
+                },
+                "end": {
+                  "line": 49,
+                  "column": 14
+                }
+              }
+            },
+            "default": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 17
+                },
+                "end": {
+                  "line": 49,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 49,
+                "column": 13
+              },
+              "end": {
+                "line": 49,
+                "column": 24
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 25
+                },
+                "end": {
+                  "line": 49,
+                  "column": 26
+                }
+              }
+            },
+            "default": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 37
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "I",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "typeParameters": {
+                    "type": "TSTypeParameterInstantiation",
+                    "params": [
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 42
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 48
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 41
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 29
+                },
+                "end": {
+                  "line": 49,
+                  "column": 41
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 49,
+                "column": 25
+              },
+              "end": {
+                "line": 49,
+                "column": 50
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 49,
+            "column": 12
+          },
+          "end": {
+            "line": 49,
+            "column": 50
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 49,
+          "column": 1
+        },
+        "end": {
+          "line": 50,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 43
+          },
+          "end": {
+            "line": 52,
+            "column": 46
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "O",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 11
+          },
+          "end": {
+            "line": 52,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 13
+                },
+                "end": {
+                  "line": 52,
+                  "column": 14
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 25
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 17
+                },
+                "end": {
+                  "line": 52,
+                  "column": 25
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 13
+              },
+              "end": {
+                "line": 52,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 27
+                },
+                "end": {
+                  "line": 52,
+                  "column": 28
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "I",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 32
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 40
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 42
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 31
+                },
+                "end": {
+                  "line": 52,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 27
+              },
+              "end": {
+                "line": 52,
+                "column": 42
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 12
+          },
+          "end": {
+            "line": 52,
+            "column": 42
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 52,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 26
+          },
+          "end": {
+            "line": 54,
+            "column": 29
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "L",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 11
+          },
+          "end": {
+            "line": 54,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 13
+                },
+                "end": {
+                  "line": 54,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 13
+              },
+              "end": {
+                "line": 54,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 16
+                },
+                "end": {
+                  "line": 54,
+                  "column": 17
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 16
+              },
+              "end": {
+                "line": 54,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "O",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 19
+                },
+                "end": {
+                  "line": 54,
+                  "column": 20
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 23
+                },
+                "end": {
+                  "line": 54,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 19
+              },
+              "end": {
+                "line": 54,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 12
+          },
+          "end": {
+            "line": 54,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 54,
+          "column": 29
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 55,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/generic_interface.ts b/es2panda/test/compiler/ts/generic_interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..afe3714ea5b3c8139c9ba0a2bc1bc07421f83038
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_interface.ts
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface R<T = number> {
+    a: T;
+}
+
+var var1: R;
+var1.a = 5;
+
+var var2: R<string>;
+var2.a = "foo";
+
+interface U<Z, W> extends R {
+    b: Z | W;
+}
+
+var var3: U<boolean, number>;
+var3.a = 12;
+var3.b = true;
+var3.b = 32;
+
+interface V<T = number> {
+    a: T[];
+}
+
+interface V {
+    b: string[]
+}
+
+var var4: V;
+var4.a = [1, 2, 3];
+var4.b = ["bar", "baz"];
+
+interface C<E, F = { a: number, b: string }> {
+    a: E;
+    b: F;
+}
+
+var var5: C<[number]>;
+var5.a = [2];
+var5.b = { a: 3, b: "foo" };
+
+interface I<A> {
+    aa: A
+}
+
+var a: {
+    aa: number
+}
+
+interface A<T = string, B = typeof a | I<string>> {
+}
+
+interface O<T = typeof a, B = I<boolean>> { }
+
+interface L<T, B, O = A> { }
diff --git a/es2panda/test/compiler/ts/generic_type_alias-expected.txt b/es2panda/test/compiler/ts/generic_type_alias-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..73a1d961c83820d7e741fe4744e5d50c709f049d
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias-expected.txt
@@ -0,0 +1,4049 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 13
+              },
+              "end": {
+                "line": 1,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 22
+              },
+              "end": {
+                "line": 1,
+                "column": 23
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 1,
+            "column": 23
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 8
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 7
+          },
+          "end": {
+            "line": 1,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 23
+        },
+        "end": {
+          "line": 1,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var1",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 4,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 8
+            },
+            "end": {
+              "line": 4,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 8
+            },
+            "end": {
+              "line": 5,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var2",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 11
+                },
+                "end": {
+                  "line": 7,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 8
+            },
+            "end": {
+              "line": 8,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var3",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 10,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 10,
+                          "column": 14
+                        }
+                      }
+                    },
+                    "typeParameters": {
+                      "type": "TSTypeParameterInstantiation",
+                      "params": [
+                        {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 22
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 10,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 10,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 14
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 11
+                },
+                "end": {
+                  "line": 10,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 1
+            },
+            "end": {
+              "line": 11,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 8
+            },
+            "end": {
+              "line": 11,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 1
+          },
+          "end": {
+            "line": 11,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": true,
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 8
+            },
+            "end": {
+              "line": 12,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 6
+          },
+          "end": {
+            "line": 14,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTupleType",
+        "elementTypes": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "R",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 26
+                },
+                "end": {
+                  "line": 14,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 26
+              },
+              "end": {
+                "line": 14,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 29
+                },
+                "end": {
+                  "line": 14,
+                  "column": 30
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 29
+              },
+              "end": {
+                "line": 14,
+                "column": 31
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 25
+          },
+          "end": {
+            "line": 14,
+            "column": 31
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "R",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 8
+                },
+                "end": {
+                  "line": 14,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 8
+              },
+              "end": {
+                "line": 14,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 11
+                },
+                "end": {
+                  "line": 14,
+                  "column": 12
+                }
+              }
+            },
+            "default": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 15
+                },
+                "end": {
+                  "line": 14,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 11
+              },
+              "end": {
+                "line": 14,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 7
+          },
+          "end": {
+            "line": 14,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 31
+        },
+        "end": {
+          "line": 14,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var4",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 11
+                },
+                "end": {
+                  "line": 16,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 5
+              },
+              "end": {
+                "line": 16,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 5
+            },
+            "end": {
+              "line": 16,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 9
+                },
+                "end": {
+                  "line": 17,
+                  "column": 14
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 12,
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 16
+                },
+                "end": {
+                  "line": 17,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 8
+            },
+            "end": {
+              "line": 17,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var5",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 19,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 19,
+                        "column": 19
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 19,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 19,
+                        "column": 28
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 29
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 11
+                },
+                "end": {
+                  "line": 19,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 5
+              },
+              "end": {
+                "line": 19,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 5
+            },
+            "end": {
+              "line": 19,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var5",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 9
+                },
+                "end": {
+                  "line": 20,
+                  "column": 10
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": true,
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 12
+                },
+                "end": {
+                  "line": 20,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 8
+            },
+            "end": {
+              "line": 20,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var6",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 14
+                        }
+                      }
+                    },
+                    "typeParameters": {
+                      "type": "TSTypeParameterInstantiation",
+                      "params": [
+                        {
+                          "type": "TSTypeLiteral",
+                          "members": [
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 20
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 26
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 22,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 22,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 31
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 37
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 22,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 22,
+                                  "column": 39
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 22,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 22,
+                              "column": 39
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 41
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 14
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 41
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 11
+                },
+                "end": {
+                  "line": 22,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 5
+              },
+              "end": {
+                "line": 22,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 5
+            },
+            "end": {
+              "line": 22,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 12
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 9
+                },
+                "end": {
+                  "line": 23,
+                  "column": 27
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 12,
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 29
+                },
+                "end": {
+                  "line": 23,
+                  "column": 31
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 8
+            },
+            "end": {
+              "line": 23,
+              "column": 32
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 32
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 12,
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 10
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 14
+                        }
+                      }
+                    },
+                    {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 20
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 21
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 9
+              },
+              "end": {
+                "line": 28,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 28,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "z",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 5
+              },
+              "end": {
+                "line": 30,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "SpreadElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "o",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 9
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 9
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 32,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 32,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 32,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 32,
+                            "column": 19
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 32,
+                              "column": 32
+                            },
+                            "end": {
+                              "line": 32,
+                              "column": 38
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 32,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 32,
+                            "column": 30
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 32,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 32,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 41
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 49
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "ArrayExpression",
+                            "elements": [
+                              {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 33,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 33,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              {
+                                "type": "NumberLiteral",
+                                "value": 2,
+                                "loc": {
+                                  "start": {
+                                    "line": 33,
+                                    "column": 20
+                                  },
+                                  "end": {
+                                    "line": 33,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              {
+                                "type": "NumberLiteral",
+                                "value": 3,
+                                "loc": {
+                                  "start": {
+                                    "line": 33,
+                                    "column": 23
+                                  },
+                                  "end": {
+                                    "line": 33,
+                                    "column": 24
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 16
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 26
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 6
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 6
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 9
+              },
+              "end": {
+                "line": 35,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 5
+            },
+            "end": {
+              "line": 35,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 6
+          },
+          "end": {
+            "line": 37,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSArrayType",
+        "elementType": {
+          "type": "TSParenthesizedType",
+          "typeAnnotation": {
+            "type": "TSUnionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "T",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 46
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 46
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "E",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 50
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 50
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 45
+              },
+              "end": {
+                "line": 37,
+                "column": 50
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 44
+            },
+            "end": {
+              "line": 37,
+              "column": 51
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 44
+          },
+          "end": {
+            "line": 37,
+            "column": 53
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 8
+                },
+                "end": {
+                  "line": 37,
+                  "column": 9
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "z",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 12
+                },
+                "end": {
+                  "line": 37,
+                  "column": 20
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 8
+              },
+              "end": {
+                "line": 37,
+                "column": 21
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "E",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 22
+                },
+                "end": {
+                  "line": 37,
+                  "column": 23
+                }
+              }
+            },
+            "default": {
+              "type": "TSFunctionType",
+              "params": [],
+              "returnType": {
+                "type": "TSArrayType",
+                "elementType": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 38
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 40
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 26
+                },
+                "end": {
+                  "line": 37,
+                  "column": 40
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 22
+              },
+              "end": {
+                "line": 37,
+                "column": 41
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 7
+          },
+          "end": {
+            "line": 37,
+            "column": 41
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 54
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 53
+        },
+        "end": {
+          "line": 37,
+          "column": 54
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var7",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "C",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 12
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 11
+                },
+                "end": {
+                  "line": 39,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 5
+              },
+              "end": {
+                "line": 39,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 39,
+              "column": 5
+            },
+            "end": {
+              "line": 39,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 39,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 1
+            },
+            "end": {
+              "line": 40,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 8
+            },
+            "end": {
+              "line": 40,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 40,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 1
+            },
+            "end": {
+              "line": 41,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 12
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 26
+                          }
+                        }
+                      },
+                      {
+                        "type": "BooleanLiteral",
+                        "value": false,
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 33
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 34
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "FunctionExpression",
+                    "function": {
+                      "type": "ScriptFunction",
+                      "id": null,
+                      "generator": false,
+                      "async": false,
+                      "expression": false,
+                      "params": [],
+                      "body": {
+                        "type": "BlockStatement",
+                        "statements": [
+                          {
+                            "type": "ReturnStatement",
+                            "argument": {
+                              "type": "ArrayExpression",
+                              "elements": [
+                                {
+                                  "type": "NumberLiteral",
+                                  "value": 1,
+                                  "loc": {
+                                    "start": {
+                                      "line": 41,
+                                      "column": 61
+                                    },
+                                    "end": {
+                                      "line": 41,
+                                      "column": 62
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 41,
+                                  "column": 60
+                                },
+                                "end": {
+                                  "line": 41,
+                                  "column": 63
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 41,
+                                "column": 53
+                              },
+                              "end": {
+                                "line": 41,
+                                "column": 63
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 51
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 65
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 41,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 41,
+                          "column": 65
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 36
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 65
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 9
+                },
+                "end": {
+                  "line": 41,
+                  "column": 67
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 8
+            },
+            "end": {
+              "line": 41,
+              "column": 68
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 1
+          },
+          "end": {
+            "line": 41,
+            "column": 68
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 69
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 1
+            },
+            "end": {
+              "line": 42,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 1,
+                            "loc": {
+                              "start": {
+                                "line": 43,
+                                "column": 13
+                              },
+                              "end": {
+                                "line": 43,
+                                "column": 14
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 43,
+                                "column": 16
+                              },
+                              "end": {
+                                "line": 43,
+                                "column": 17
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 43,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 43,
+                                "column": 20
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 43,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 43,
+                            "column": 21
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 43,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 43,
+                          "column": 22
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 42,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 9
+                },
+                "end": {
+                  "line": 44,
+                  "column": 2
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 8
+            },
+            "end": {
+              "line": 44,
+              "column": 3
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 1
+          },
+          "end": {
+            "line": 44,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 44,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 1
+            },
+            "end": {
+              "line": 45,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 12
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 26
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "FunctionExpression",
+                    "function": {
+                      "type": "ScriptFunction",
+                      "id": null,
+                      "generator": false,
+                      "async": false,
+                      "expression": false,
+                      "params": [
+                        {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 45,
+                                "column": 45
+                              },
+                              "end": {
+                                "line": 45,
+                                "column": 51
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 45,
+                              "column": 42
+                            },
+                            "end": {
+                              "line": 45,
+                              "column": 43
+                            }
+                          }
+                        },
+                        {
+                          "type": "Identifier",
+                          "name": "b",
+                          "typeAnnotation": {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 45,
+                                "column": 56
+                              },
+                              "end": {
+                                "line": 45,
+                                "column": 62
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 45,
+                              "column": 53
+                            },
+                            "end": {
+                              "line": 45,
+                              "column": 54
+                            }
+                          }
+                        }
+                      ],
+                      "body": {
+                        "type": "BlockStatement",
+                        "statements": [
+                          {
+                            "type": "ReturnStatement",
+                            "argument": {
+                              "type": "ArrayExpression",
+                              "elements": [],
+                              "loc": {
+                                "start": {
+                                  "line": 45,
+                                  "column": 73
+                                },
+                                "end": {
+                                  "line": 45,
+                                  "column": 75
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 45,
+                                "column": 66
+                              },
+                              "end": {
+                                "line": 45,
+                                "column": 75
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 64
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 77
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 45,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 45,
+                          "column": 77
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 77
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 77
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 9
+                },
+                "end": {
+                  "line": 45,
+                  "column": 79
+                }
+              }
+            },
+            {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 45,
+                                "column": 103
+                              },
+                              "end": {
+                                "line": 45,
+                                "column": 104
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 102
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 105
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 45,
+                          "column": 95
+                        },
+                        "end": {
+                          "line": 45,
+                          "column": 105
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 93
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 107
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 81
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 107
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 81
+                },
+                "end": {
+                  "line": 45,
+                  "column": 107
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 8
+            },
+            "end": {
+              "line": 45,
+              "column": 108
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 45,
+            "column": 1
+          },
+          "end": {
+            "line": 45,
+            "column": 108
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 45,
+          "column": 1
+        },
+        "end": {
+          "line": 45,
+          "column": 109
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var8",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "C",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 47,
+                    "column": 12
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 47,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 47,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 47,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 11
+                },
+                "end": {
+                  "line": 47,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 5
+              },
+              "end": {
+                "line": 47,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 5
+            },
+            "end": {
+              "line": 47,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 47,
+          "column": 1
+        },
+        "end": {
+          "line": 47,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var8",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 48,
+              "column": 1
+            },
+            "end": {
+              "line": 48,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 9
+                },
+                "end": {
+                  "line": 48,
+                  "column": 10
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 12
+                },
+                "end": {
+                  "line": 48,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 3,
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 15
+                },
+                "end": {
+                  "line": 48,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 48,
+              "column": 8
+            },
+            "end": {
+              "line": 48,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 48,
+            "column": 1
+          },
+          "end": {
+            "line": 48,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 48,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 10
+            },
+            "end": {
+              "line": 50,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSArrayType",
+          "elementType": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 18
+              },
+              "end": {
+                "line": 50,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 18
+            },
+            "end": {
+              "line": 50,
+              "column": 26
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 51,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 51,
+                        "column": 14
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 51,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 51,
+                        "column": 17
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 51,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 51,
+                        "column": 20
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 4,
+                    "loc": {
+                      "start": {
+                        "line": 51,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 51,
+                        "column": 23
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 51,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 51,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 5
+                },
+                "end": {
+                  "line": 51,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 27
+            },
+            "end": {
+              "line": 52,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 1
+          },
+          "end": {
+            "line": 52,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var8",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 1
+            },
+            "end": {
+              "line": 54,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 9
+                },
+                "end": {
+                  "line": 54,
+                  "column": 10
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "func",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 12
+                },
+                "end": {
+                  "line": 54,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 8
+            },
+            "end": {
+              "line": 54,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 1
+          },
+          "end": {
+            "line": 54,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 54,
+          "column": 18
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 55,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/generic_type_alias.ts b/es2panda/test/compiler/ts/generic_type_alias.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6f62324f5bd18e8314d9f9910a162d7a326ffca2
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias.ts
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A<T> = number | T;
+
+var var1: A<string>;
+var1 = 4;
+var1 = "foo";
+
+var var2: A<number>;
+var2 = 1;
+
+var var3: A<A<boolean>>;
+var3 = 2;
+var3 = true;
+
+type B<R, T = number> = [R, T];
+
+var var4: B<string>;
+var4 = ["foo", 12];
+
+var var5: B<number, boolean>;
+var5 = [4, true];
+
+var var6: B<A<{ a: number, b: string }>>;
+var6 = [{ a: 2, b: "foo" }, 12];
+
+var o = {
+    a: 12,
+    b: ["foo", true],
+}
+
+var z = {
+    ...o,
+    c: function (a: number, b: string): number[] {
+        return [1, 2, 3];
+    }
+}
+
+type C<T = typeof z, E = () => number[]> = (T | E)[];
+
+var var7: C;
+var7 = [];
+var7 = [{ a: 2, b: ["bar", false], c: function () { return [1] } }];
+var7 = [function () {
+    return [1, 2, 3];
+}];
+var7 = [{ a: 1, b: ["baz"], c: function (a: number, b: string) { return [] } }, function () { return [2] }];
+
+var var8: C<number>;
+var8 = [1, 2, 3];
+
+function func(): number[] {
+    return [1, 2, 3, 4];
+}
+
+var8 = [1, func];
diff --git a/es2panda/test/compiler/ts/generic_type_alias_1-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..11d2aeec93c1dcc61bccb273a417f73d1f1910f7
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_1-expected.txt
@@ -0,0 +1,201 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTypeReference",
+        "typeName": {
+          "type": "Identifier",
+          "name": "T",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 13
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 8
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 7
+          },
+          "end": {
+            "line": 1,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 14
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Generic type 'A' requires '1' type argument(s). [generic_type_alias_1.ts:3:8]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_1.ts b/es2panda/test/compiler/ts/generic_type_alias_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c66b5d8e313141e022b0f63191a94836e6ed349
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A<T> = T;
+
+var a: A;
diff --git a/es2panda/test/compiler/ts/generic_type_alias_10-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..daf41841294ceec69f375555a1ab70744f47922b
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_10-expected.txt
@@ -0,0 +1,708 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSArrayType",
+        "elementType": {
+          "type": "TSParenthesizedType",
+          "typeAnnotation": {
+            "type": "TSUnionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "T",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 80
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 81
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 80
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 81
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "B",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 85
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 84
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 85
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 80
+              },
+              "end": {
+                "line": 1,
+                "column": 85
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 79
+            },
+            "end": {
+              "line": 1,
+              "column": 86
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 79
+          },
+          "end": {
+            "line": 1,
+            "column": 88
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 9
+                }
+              }
+            },
+            "default": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 12
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 8
+              },
+              "end": {
+                "line": 1,
+                "column": 46
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 47
+                },
+                "end": {
+                  "line": 1,
+                  "column": 48
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 62
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 53
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 63
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 64
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 73
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 64
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 75
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 51
+                },
+                "end": {
+                  "line": 1,
+                  "column": 75
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 47
+              },
+              "end": {
+                "line": 1,
+                "column": 76
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 7
+          },
+          "end": {
+            "line": 1,
+            "column": 76
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 89
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 88
+        },
+        "end": {
+          "line": 1,
+          "column": 89
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 13
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 9
+              },
+              "end": {
+                "line": 8,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 1
+            },
+            "end": {
+              "line": 10,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "o",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 6
+                },
+                "end": {
+                  "line": 10,
+                  "column": 7
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 1
+          },
+          "end": {
+            "line": 10,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '{ a: string; b: string; }' is not assignable to type '(a: number, b: string) => boolean | { a: number; b: string; }'. [generic_type_alias_10.ts:10:6]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_10.ts b/es2panda/test/compiler/ts/generic_type_alias_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..014791a44379ec4f103a5c7a415a0e303053d867
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_10.ts
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A<T = (a: number, b: string) => boolean, B = { a: number, b: string }> = (T | B)[];
+
+var a: A;
+
+var o = {
+    a: "foo",
+    b: "bar",
+}
+
+a = [o];
diff --git a/es2panda/test/compiler/ts/generic_type_alias_2-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6c33dd8b6ceb485933a29045a2e9f7e1aa7da809
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_2-expected.txt
@@ -0,0 +1,285 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "R",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 25
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 29
+                },
+                "end": {
+                  "line": 1,
+                  "column": 30
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 29
+              },
+              "end": {
+                "line": 1,
+                "column": 30
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 25
+          },
+          "end": {
+            "line": 1,
+            "column": 30
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 8
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "R",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 12
+                }
+              }
+            },
+            "default": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 15
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 11
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 7
+          },
+          "end": {
+            "line": 1,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 30
+        },
+        "end": {
+          "line": 1,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Generic type 'A' requires between '1' and '2' type arguments. [generic_type_alias_2.ts:3:8]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_2.ts b/es2panda/test/compiler/ts/generic_type_alias_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e54bbcd501b475015596bc0bb15729fb90ddd7a9
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A<T, R = number> = R | T;
+
+var a: A;
diff --git a/es2panda/test/compiler/ts/generic_type_alias_3-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d5388a649b70d936a09c46e31916c429a0f0dbb
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_3-expected.txt
@@ -0,0 +1,270 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTypeReference",
+        "typeName": {
+          "type": "Identifier",
+          "name": "T",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 22
+            },
+            "end": {
+              "line": 1,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 22
+          },
+          "end": {
+            "line": 1,
+            "column": 23
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 9
+                }
+              }
+            },
+            "default": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 12
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 8
+              },
+              "end": {
+                "line": 1,
+                "column": 19
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 7
+          },
+          "end": {
+            "line": 1,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 23
+        },
+        "end": {
+          "line": 1,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'number'. [generic_type_alias_3.ts:4:1]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_3.ts b/es2panda/test/compiler/ts/generic_type_alias_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc8615b25cbe4b4fdc0f699d7e1aa0210ab15be5
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_3.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A<T = number> = T;
+
+var a: A;
+a = "foo";
diff --git a/es2panda/test/compiler/ts/generic_type_alias_4-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f613a2a801b25f5c4616707ad09c027a09f85f38
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_4-expected.txt
@@ -0,0 +1,466 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 6
+                },
+                "end": {
+                  "line": 1,
+                  "column": 7
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 6
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTupleType",
+        "elementTypes": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 31
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 31
+              },
+              "end": {
+                "line": 3,
+                "column": 33
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 34
+                },
+                "end": {
+                  "line": 3,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 34
+              },
+              "end": {
+                "line": 3,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 37
+                },
+                "end": {
+                  "line": 3,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 37
+              },
+              "end": {
+                "line": 3,
+                "column": 39
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 30
+          },
+          "end": {
+            "line": 3,
+            "column": 39
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 8
+              },
+              "end": {
+                "line": 3,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 11
+              },
+              "end": {
+                "line": 3,
+                "column": 13
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 14
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "default": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 7
+          },
+          "end": {
+            "line": 3,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 39
+        },
+        "end": {
+          "line": 3,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 9
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 16
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [generic_type_alias_4.ts:1:6]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_4.ts b/es2panda/test/compiler/ts/generic_type_alias_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7452496ffd33f5a267e8072d725abfe8a1625e21
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_4.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = [1];
+
+type A<T, B, C = number[]> = [T, B, C];
+
+var a: A<string, boolean>
diff --git a/es2panda/test/compiler/ts/generic_type_alias_5-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a16b0e10cb728447fee05f93ba37bb123976ebd0
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_5-expected.txt
@@ -0,0 +1,480 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 6
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 13
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 6
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTupleType",
+        "elementTypes": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 31
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 31
+              },
+              "end": {
+                "line": 3,
+                "column": 33
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 34
+                },
+                "end": {
+                  "line": 3,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 34
+              },
+              "end": {
+                "line": 3,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 37
+                },
+                "end": {
+                  "line": 3,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 37
+              },
+              "end": {
+                "line": 3,
+                "column": 39
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 30
+          },
+          "end": {
+            "line": 3,
+            "column": 39
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 8
+              },
+              "end": {
+                "line": 3,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 11
+              },
+              "end": {
+                "line": 3,
+                "column": 13
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 14
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "default": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 7
+          },
+          "end": {
+            "line": 3,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 39
+        },
+        "end": {
+          "line": 3,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 9
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 16
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [generic_type_alias_5.ts:1:13]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_5.ts b/es2panda/test/compiler/ts/generic_type_alias_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e0a831497d2b44fe4dda0d606bc3d7c16cacbba
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_5.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = ["foo", 5];
+
+type A<T, B, C = number[]> = [T, B, C];
+
+var a: A<string, boolean>
diff --git a/es2panda/test/compiler/ts/generic_type_alias_6-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5a7d94e72acc4ea92deda1a33246b1baf4b57e91
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_6-expected.txt
@@ -0,0 +1,480 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 6
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": true,
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 13
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 6
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTupleType",
+        "elementTypes": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 31
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 31
+              },
+              "end": {
+                "line": 3,
+                "column": 33
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 34
+                },
+                "end": {
+                  "line": 3,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 34
+              },
+              "end": {
+                "line": 3,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 37
+                },
+                "end": {
+                  "line": 3,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 37
+              },
+              "end": {
+                "line": 3,
+                "column": 39
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 30
+          },
+          "end": {
+            "line": 3,
+            "column": 39
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 8
+              },
+              "end": {
+                "line": 3,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 11
+              },
+              "end": {
+                "line": 3,
+                "column": 13
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 14
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "default": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 7
+          },
+          "end": {
+            "line": 3,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 39
+        },
+        "end": {
+          "line": 3,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 9
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 16
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '[string, boolean]' is not assignable to type '[string, boolean, number[]]'. [generic_type_alias_6.ts:1:1]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_6.ts b/es2panda/test/compiler/ts/generic_type_alias_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..de649d98a0179601584b03699aea4297049b28cc
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_6.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = ["foo", true];
+
+type A<T, B, C = number[]> = [T, B, C];
+
+var a: A<string, boolean>
diff --git a/es2panda/test/compiler/ts/generic_type_alias_7-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..05fc0d19e1afa6b65d9e7a6e7f21a35f5a37097b
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_7-expected.txt
@@ -0,0 +1,539 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTupleType",
+        "elementTypes": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 17
+              },
+              "end": {
+                "line": 1,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 20
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 20
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 16
+          },
+          "end": {
+            "line": 1,
+            "column": 22
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 8
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 11
+              },
+              "end": {
+                "line": 1,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 7
+          },
+          "end": {
+            "line": 1,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 22
+        },
+        "end": {
+          "line": 1,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 6
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTypeReference",
+        "typeName": {
+          "type": "Identifier",
+          "name": "R",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 13
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 13
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "R",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 8
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 7
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 14
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 9
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 11
+                        }
+                      }
+                    },
+                    "typeParameters": {
+                      "type": "TSTypeParameterInstantiation",
+                      "params": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 18
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 26
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 28
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 11
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 28
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 6
+                },
+                "end": {
+                  "line": 5,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [generic_type_alias_7.ts:5:6]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_7.ts b/es2panda/test/compiler/ts/generic_type_alias_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5464ca6c8f2f84f69c39b513b3948c4e690b1d7c
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_7.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A<T, B> = [T, B];
+type B<R> = R;
+
+var a: B<A<number, string>>;
+a = ["foo"];
diff --git a/es2panda/test/compiler/ts/generic_type_alias_8-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5bf355700648ed8c03b4cb3247e81454ee018068
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_8-expected.txt
@@ -0,0 +1,806 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 12,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 10
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": true,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 10
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 7
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 8
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 3,
+                                "column": 38
+                              },
+                              "end": {
+                                "line": 3,
+                                "column": 43
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 44
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 29
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 46
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 46
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 4,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 6
+          },
+          "end": {
+            "line": 6,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTypeLiteral",
+        "members": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 29
+                },
+                "end": {
+                  "line": 6,
+                  "column": 30
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 33
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 32
+                },
+                "end": {
+                  "line": 6,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 29
+              },
+              "end": {
+                "line": 6,
+                "column": 34
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 35
+                },
+                "end": {
+                  "line": 6,
+                  "column": 36
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 39
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 38
+                },
+                "end": {
+                  "line": 6,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 35
+              },
+              "end": {
+                "line": 6,
+                "column": 41
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 27
+          },
+          "end": {
+            "line": 6,
+            "column": 41
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 8
+              },
+              "end": {
+                "line": 6,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 11
+                },
+                "end": {
+                  "line": 6,
+                  "column": 12
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "o",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 15
+                },
+                "end": {
+                  "line": 6,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 11
+              },
+              "end": {
+                "line": 6,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 7
+          },
+          "end": {
+            "line": 6,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 41
+        },
+        "end": {
+          "line": 6,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 9
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 16
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 17
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 1
+            },
+            "end": {
+              "line": 9,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 8
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 7
+                },
+                "end": {
+                  "line": 9,
+                  "column": 15
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 18
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 21
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 17
+                },
+                "end": {
+                  "line": 9,
+                  "column": 21
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 1
+          },
+          "end": {
+            "line": 9,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 10,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type '{ a: number; b(a: number, b: string) => string; }'. [generic_type_alias_8.ts:9:17]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_8.ts b/es2panda/test/compiler/ts/generic_type_alias_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..037617b67dabefcd329ebbcde557846769515077
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_8.ts
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var o = {
+    a: 12,
+    b(a: number, b: string) { return "foo"; }
+}
+
+type A<T, B = typeof o> = { a: T, b: B };
+var a: A<string>;
+
+a = { a: "foo", b: 5 };
diff --git a/es2panda/test/compiler/ts/generic_type_alias_9-expected.txt b/es2panda/test/compiler/ts/generic_type_alias_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6b0ad6a91cf39560c3abc68bd3f22b3e444069e4
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_9-expected.txt
@@ -0,0 +1,701 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSArrayType",
+        "elementType": {
+          "type": "TSParenthesizedType",
+          "typeAnnotation": {
+            "type": "TSUnionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "T",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 80
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 81
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 80
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 81
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "B",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 85
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 84
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 85
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 80
+              },
+              "end": {
+                "line": 1,
+                "column": 85
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 79
+            },
+            "end": {
+              "line": 1,
+              "column": 86
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 79
+          },
+          "end": {
+            "line": 1,
+            "column": 88
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 9
+                }
+              }
+            },
+            "default": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 12
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 8
+              },
+              "end": {
+                "line": 1,
+                "column": 46
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 47
+                },
+                "end": {
+                  "line": 1,
+                  "column": 48
+                }
+              }
+            },
+            "default": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 62
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 53
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 63
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 64
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 73
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 64
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 75
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 51
+                },
+                "end": {
+                  "line": 1,
+                  "column": 75
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 47
+              },
+              "end": {
+                "line": 1,
+                "column": 76
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 7
+          },
+          "end": {
+            "line": 1,
+            "column": 76
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 89
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 88
+        },
+        "end": {
+          "line": 1,
+          "column": 89
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 10
+            },
+            "end": {
+              "line": 5,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 18
+                },
+                "end": {
+                  "line": 5,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 15
+              },
+              "end": {
+                "line": 5,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 29
+                },
+                "end": {
+                  "line": 5,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 26
+              },
+              "end": {
+                "line": 5,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 37
+            },
+            "end": {
+              "line": 7,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 1
+            },
+            "end": {
+              "line": 9,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "func",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 6
+                },
+                "end": {
+                  "line": 9,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 1
+          },
+          "end": {
+            "line": 9,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 10,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '(a: string, b: string) => boolean' is not assignable to type '(a: number, b: string) => boolean | { a: number; b: string; }'. [generic_type_alias_9.ts:9:6]
diff --git a/es2panda/test/compiler/ts/generic_type_alias_9.ts b/es2panda/test/compiler/ts/generic_type_alias_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1c6bfaa90f7edd72f0cbbd70a9dc9306f39b8881
--- /dev/null
+++ b/es2panda/test/compiler/ts/generic_type_alias_9.ts
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A<T = (a: number, b: string) => boolean, B = { a: number, b: string }> = (T | B)[];
+
+var a: A;
+
+function func(a: string, b: string) {
+    return true;
+}
+
+a = [func];
diff --git a/es2panda/test/compiler/ts/identifierWithoutDeclaration-expected.txt b/es2panda/test/compiler/ts/identifierWithoutDeclaration-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..445a099fa0d95f9d43fcbfe9a9ec5a2316e48b22
--- /dev/null
+++ b/es2panda/test/compiler/ts/identifierWithoutDeclaration-expected.txt
@@ -0,0 +1,315 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 4,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 7
+            },
+            "end": {
+              "line": 5,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 9
+    }
+  }
+}
+TypeError: Cannot find name foo [identifierWithoutDeclaration.ts:5:1]
diff --git a/es2panda/test/compiler/ts/identifierWithoutDeclaration.ts b/es2panda/test/compiler/ts/identifierWithoutDeclaration.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf4ebb132e807f21843e28461aef1c2a5e37c150
--- /dev/null
+++ b/es2panda/test/compiler/ts/identifierWithoutDeclaration.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = 5;
+var a: number;
+var b: typeof a;
+b = 12;
+foo = 4;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/in_1-expected.txt b/es2panda/test/compiler/ts/in_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7e153fe7fe2a902571ac4a57e083fb31723ad36e
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_1-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNullKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Object is possibly 'null'. [in_1.ts:3:1]
diff --git a/es2panda/test/compiler/ts/in_1.ts b/es2panda/test/compiler/ts/in_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ca31895edf136508c0543f57024b88325d4d3fe6
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: null;
+var b: any;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_10-expected.txt b/es2panda/test/compiler/ts/in_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..973ad9cd9d82ceaec1a599dfbf863816403f3616
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_10-expected.txt
@@ -0,0 +1,230 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSParenthesizedType",
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_10.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_10.ts b/es2panda/test/compiler/ts/in_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..633e2cbb4cb594155b237182d5ec65d151fcaad1
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: (string|number);
+var b: number;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_11-expected.txt b/es2panda/test/compiler/ts/in_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6630c41ed1a879f6a1e5eae38a57059a34260756
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_11-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_11.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_11.ts b/es2panda/test/compiler/ts/in_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5dd55c4a309b20d88310f5dcb8cb1fa9af1bbb6b
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: string;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_12-expected.txt b/es2panda/test/compiler/ts/in_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..66a63205f5087df1dfd4884732202fa719734b0e
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_12-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_12.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_12.ts b/es2panda/test/compiler/ts/in_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c20b34183fb613acb72ebecbf69b1bb6a1e3f2c
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: number;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_13-expected.txt b/es2panda/test/compiler/ts/in_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1a31836863e917c93af0ea6b58d5a1e248cce44f
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_13-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_13.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_13.ts b/es2panda/test/compiler/ts/in_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3bdbed1dc5b3e449ea47188e865f978f03db7c55
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_13.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: bigint;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_14-expected.txt b/es2panda/test/compiler/ts/in_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2e56615c1ed4cc5e15bba9cff7d86c50cf4d1fe0
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_14-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_14.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_14.ts b/es2panda/test/compiler/ts/in_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f8b363eba7044dc30d3677da0c100c69257ae0c0
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_14.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: boolean;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_15-expected.txt b/es2panda/test/compiler/ts/in_15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2590d4a53c93b927486bd978b154991009a06754
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_15-expected.txt
@@ -0,0 +1,256 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSParenthesizedType",
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 22
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBigIntKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 29
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 37
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_15.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_15.ts b/es2panda/test/compiler/ts/in_15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1d491242bd3b0ef78dbe3e738b72c6ac6333ae23
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_15.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: (string|number|bigint|boolean);
+a in b;
diff --git a/es2panda/test/compiler/ts/in_2-expected.txt b/es2panda/test/compiler/ts/in_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5dfae22c02a0ae5c4748d37f932825376d0642c8
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_2-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNullKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Object is possibly 'null'. [in_2.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_2.ts b/es2panda/test/compiler/ts/in_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..490e08ddc08a003adfb013db6f3aece84270bda8
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: null;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_3-expected.txt b/es2panda/test/compiler/ts/in_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..61551e82460abac69f0606dbe763ba73d7ce5a97
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_3-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUndefinedKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Object is possibly 'undefined'. [in_3.ts:3:1]
diff --git a/es2panda/test/compiler/ts/in_3.ts b/es2panda/test/compiler/ts/in_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..37b7e4c7c237648e129ab5575ab65a029105c968
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: undefined;
+var b: any;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_4-expected.txt b/es2panda/test/compiler/ts/in_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0e7244be1d1e56bbacaee0de631b950f6f8dedfc
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_4-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSUndefinedKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Object is possibly 'undefined'. [in_4.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_4.ts b/es2panda/test/compiler/ts/in_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9ffe051f07d88fbd9bef7bd5935e88c55beb19ae
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: undefined;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_5-expected.txt b/es2panda/test/compiler/ts/in_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d1b8de2e80405cecd5b248bb1707b93a4e2c4203
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_5-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'. [in_5.ts:3:1]
diff --git a/es2panda/test/compiler/ts/in_5.ts b/es2panda/test/compiler/ts/in_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c5fc38aab63e9bc7170f445fe73347b656f1bff2
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+var b: any;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_6-expected.txt b/es2panda/test/compiler/ts/in_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..079069822d13b4cbe6052f45c4680d25b8b6d150
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_6-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'. [in_6.ts:3:1]
diff --git a/es2panda/test/compiler/ts/in_6.ts b/es2panda/test/compiler/ts/in_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0f48b7b938ed6607a692cafc0914b52508a55ec4
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_6.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+var b: any;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_7-expected.txt b/es2panda/test/compiler/ts/in_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b7e85cea882d5cc9659b0b432edeac9f84fe2d54
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_7-expected.txt
@@ -0,0 +1,256 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSParenthesizedType",
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBigIntKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 29
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'. [in_7.ts:3:1]
diff --git a/es2panda/test/compiler/ts/in_7.ts b/es2panda/test/compiler/ts/in_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d883a39b30e762ef66f48c098517962600ef2047
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: (string|number|bigint|boolean);
+var b: any;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_8-expected.txt b/es2panda/test/compiler/ts/in_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..93fe24d2f9788d4fe5f893070d0daceab9a7de04
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_8-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_8.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_8.ts b/es2panda/test/compiler/ts/in_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..944b31b1ab81265f6019828c9e193aa8787fae0b
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var b: number;
+a in b;
diff --git a/es2panda/test/compiler/ts/in_9-expected.txt b/es2panda/test/compiler/ts/in_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d19d61f52ee78c063973101e36bbf87b4516d7d9
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_9-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 6
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'in' expression must not be a primitive. [in_9.ts:3:6]
diff --git a/es2panda/test/compiler/ts/in_9.ts b/es2panda/test/compiler/ts/in_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1d57c14c155c4f0d6230d0a1544d2f492692eab4
--- /dev/null
+++ b/es2panda/test/compiler/ts/in_9.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+var b: number;
+a in b;
diff --git a/es2panda/test/compiler/ts/instanceof_1-expected.txt b/es2panda/test/compiler/ts/instanceof_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..421890e92146019f25c6d9b0d3834dac8d53e408
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_1-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_1.ts:3:1]
diff --git a/es2panda/test/compiler/ts/instanceof_1.ts b/es2panda/test/compiler/ts/instanceof_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e1ba32b381ae55915b01c998cd71eaac1701651
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_10-expected.txt b/es2panda/test/compiler/ts/instanceof_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..29f42de023b6b16c4fe43c05b365e81623cafb2e
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_10-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type. [instanceof_10.ts:3:14]
diff --git a/es2panda/test/compiler/ts/instanceof_10.ts b/es2panda/test/compiler/ts/instanceof_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..50e26e3cb986f8107c37824ccf94debeb23a4304
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: string;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_11-expected.txt b/es2panda/test/compiler/ts/instanceof_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5668dfe006c98a1da3dc77be96c115da4073b168
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_11-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type. [instanceof_11.ts:3:14]
diff --git a/es2panda/test/compiler/ts/instanceof_11.ts b/es2panda/test/compiler/ts/instanceof_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b793041edfbe66377e69167099aa13433daf47cc
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: number;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_12-expected.txt b/es2panda/test/compiler/ts/instanceof_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ce1265a0747ccc74219963d76f86a70d1171fbf5
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_12-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type. [instanceof_12.ts:3:14]
diff --git a/es2panda/test/compiler/ts/instanceof_12.ts b/es2panda/test/compiler/ts/instanceof_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5b832894c97e0fcc2bda3efe0479dde5e6516b3a
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: bigint;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_13-expected.txt b/es2panda/test/compiler/ts/instanceof_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4fb777df5b92f16bce75379b4d1593ee2a75c31a
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_13-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type. [instanceof_13.ts:3:14]
diff --git a/es2panda/test/compiler/ts/instanceof_13.ts b/es2panda/test/compiler/ts/instanceof_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e32c4e336a1285079faa24e0f2c98b1f8304270
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_13.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: boolean;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_14-expected.txt b/es2panda/test/compiler/ts/instanceof_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ae8d93ce572787044d4fcf82b88bccc4304f12e3
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_14-expected.txt
@@ -0,0 +1,256 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSParenthesizedType",
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 22
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBigIntKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 29
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 37
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type. [instanceof_14.ts:3:14]
diff --git a/es2panda/test/compiler/ts/instanceof_14.ts b/es2panda/test/compiler/ts/instanceof_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ec26d323e3c5ef1fc05297c7eeac813b267685df
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_14.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: any;
+var b: (string|number|bigint|boolean);
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_2-expected.txt b/es2panda/test/compiler/ts/instanceof_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d23c369c877eb4cceacd27609f764b1c07d7f329
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_2-expected.txt
@@ -0,0 +1,245 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 14
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_2.ts:4:1]
diff --git a/es2panda/test/compiler/ts/instanceof_2.ts b/es2panda/test/compiler/ts/instanceof_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..050cb25c5d81adfb7da2712a1b7dbc1638a7ba5d
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_2.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string;
+a = "foo";
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_3-expected.txt b/es2panda/test/compiler/ts/instanceof_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4e313f0e7ab513f52e30e78e102f43af1130a2cf
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_3-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_3.ts:3:1]
diff --git a/es2panda/test/compiler/ts/instanceof_3.ts b/es2panda/test/compiler/ts/instanceof_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3d3b391499876535162e0b958aafab1d24d744c2
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_4-expected.txt b/es2panda/test/compiler/ts/instanceof_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..423a13371be3f568d5606b92f8e2f1f3b1e11079
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_4-expected.txt
@@ -0,0 +1,245 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 14
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_4.ts:4:1]
diff --git a/es2panda/test/compiler/ts/instanceof_4.ts b/es2panda/test/compiler/ts/instanceof_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9bb44a0460115c75504471b17f674cdf46adb33e
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_4.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+a = 5;
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_5-expected.txt b/es2panda/test/compiler/ts/instanceof_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a9d462aaf2f08a3d0df1747fa9a2588ab3f389ff
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_5-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_5.ts:3:1]
diff --git a/es2panda/test/compiler/ts/instanceof_5.ts b/es2panda/test/compiler/ts/instanceof_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dc20dbbc8f76cd87a2fc47df6290f24d4fbf6165
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_6-expected.txt b/es2panda/test/compiler/ts/instanceof_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f785f7d9fc7bedcc5b975fbf2658e4c1d8a2dc1b
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_6-expected.txt
@@ -0,0 +1,246 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BigIntLiteral",
+          "value": "",
+          "bigint": "",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 14
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_6.ts:4:1]
diff --git a/es2panda/test/compiler/ts/instanceof_6.ts b/es2panda/test/compiler/ts/instanceof_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e70f2042b906df828caa77c54869e55425ef382a
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_6.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: bigint;
+a = 5n;
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_7-expected.txt b/es2panda/test/compiler/ts/instanceof_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dee9711b6b60d2b66c0c7f7bb009c9891b5072de
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_7-expected.txt
@@ -0,0 +1,189 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_7.ts:3:1]
diff --git a/es2panda/test/compiler/ts/instanceof_7.ts b/es2panda/test/compiler/ts/instanceof_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ca525323b9b71a117d23d4486fc4dbca62df885e
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_8-expected.txt b/es2panda/test/compiler/ts/instanceof_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..884d8c37d86a5538b9b6a97f503921ab25812e2f
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_8-expected.txt
@@ -0,0 +1,245 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 14
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_8.ts:4:1]
diff --git a/es2panda/test/compiler/ts/instanceof_8.ts b/es2panda/test/compiler/ts/instanceof_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c8ebe3890f5fee73a2a56a1176d710e88df71e5d
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_8.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: boolean;
+a = false;
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/instanceof_9-expected.txt b/es2panda/test/compiler/ts/instanceof_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f67637355c888a0ab4ca1ccc92e736293d7f858a
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_9-expected.txt
@@ -0,0 +1,256 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSParenthesizedType",
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBigIntKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 29
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter. [instanceof_9.ts:3:1]
diff --git a/es2panda/test/compiler/ts/instanceof_9.ts b/es2panda/test/compiler/ts/instanceof_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5d22fb9b47ac603b0fe8d98c45c60ff50af1b717
--- /dev/null
+++ b/es2panda/test/compiler/ts/instanceof_9.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: (string|number|bigint|boolean);
+var b: any;
+a instanceof b;
diff --git a/es2panda/test/compiler/ts/interfaceAssignment-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b21ccb0887a79bdac3a834760cfcd3ab72d7d82
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment-expected.txt
@@ -0,0 +1,3973 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 21
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 28
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 28
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 31
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 37
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 37
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 12
+              },
+              "end": {
+                "line": 7,
+                "column": 39
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 39
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSMethodSignature",
+            "computed": false,
+            "optional": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 5
+                },
+                "end": {
+                  "line": 10,
+                  "column": 6
+                }
+              }
+            },
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 16
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 27
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 30
+                },
+                "end": {
+                  "line": 10,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 39
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 23
+          },
+          "end": {
+            "line": 11,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 11
+          },
+          "end": {
+            "line": 9,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 21
+              },
+              "end": {
+                "line": 9,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 23
+            },
+            "end": {
+              "line": 9,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 8
+                },
+                "end": {
+                  "line": 13,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 9
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 9
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 12
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 19
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 19
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 22
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": false,
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 29
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 32
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 14,
+                              "column": 47
+                            },
+                            "end": {
+                              "line": 14,
+                              "column": 53
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 44
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 45
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 14,
+                              "column": 58
+                            },
+                            "end": {
+                              "line": 14,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 56
+                          }
+                        }
+                      }
+                    ],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "ArrayExpression",
+                            "elements": [
+                              {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 15,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 15,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              {
+                                "type": "NumberLiteral",
+                                "value": 2,
+                                "loc": {
+                                  "start": {
+                                    "line": 15,
+                                    "column": 20
+                                  },
+                                  "end": {
+                                    "line": 15,
+                                    "column": 21
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 15,
+                                "column": 16
+                              },
+                              "end": {
+                                "line": 15,
+                                "column": 22
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 15,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 15,
+                              "column": 23
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 66
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 6
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 6
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 12
+              },
+              "end": {
+                "line": 17,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 29
+                },
+                "end": {
+                  "line": 21,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 14
+          },
+          "end": {
+            "line": 22,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 11
+          },
+          "end": {
+            "line": 20,
+            "column": 13
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 29
+                },
+                "end": {
+                  "line": 25,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 29
+                },
+                "end": {
+                  "line": 26,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 26,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 29
+                },
+                "end": {
+                  "line": 27,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 5
+              },
+              "end": {
+                "line": 27,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 14
+          },
+          "end": {
+            "line": 28,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 11
+          },
+          "end": {
+            "line": 24,
+            "column": 13
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 29
+                },
+                "end": {
+                  "line": 31,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 5
+              },
+              "end": {
+                "line": 31,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 29
+                },
+                "end": {
+                  "line": 32,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 5
+              },
+              "end": {
+                "line": 32,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 25
+          },
+          "end": {
+            "line": 33,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 11
+          },
+          "end": {
+            "line": 30,
+            "column": 13
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "C1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 22
+              },
+              "end": {
+                "line": 30,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 25
+            },
+            "end": {
+              "line": 30,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "C2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 8
+                },
+                "end": {
+                  "line": 35,
+                  "column": 10
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 5
+              },
+              "end": {
+                "line": 35,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 5
+            },
+            "end": {
+              "line": 35,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "C3",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 8
+                },
+                "end": {
+                  "line": 36,
+                  "column": 10
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 5
+              },
+              "end": {
+                "line": 36,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 5
+            },
+            "end": {
+              "line": 36,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 5
+                },
+                "end": {
+                  "line": 39,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 8
+                },
+                "end": {
+                  "line": 39,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 5
+              },
+              "end": {
+                "line": 40,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 29
+          },
+          "end": {
+            "line": 40,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "D4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 11
+          },
+          "end": {
+            "line": 38,
+            "column": 13
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "D3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 22
+              },
+              "end": {
+                "line": 38,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 24
+            },
+            "end": {
+              "line": 38,
+              "column": 24
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "D2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 26
+              },
+              "end": {
+                "line": 38,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 29
+            },
+            "end": {
+              "line": 38,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 5
+                },
+                "end": {
+                  "line": 43,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 8
+                },
+                "end": {
+                  "line": 43,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 43,
+                "column": 5
+              },
+              "end": {
+                "line": 44,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 14
+          },
+          "end": {
+            "line": 44,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "D1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 11
+          },
+          "end": {
+            "line": 42,
+            "column": 13
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 44,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 5
+                },
+                "end": {
+                  "line": 47,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 8
+                },
+                "end": {
+                  "line": 47,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 5
+              },
+              "end": {
+                "line": 47,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 46,
+            "column": 14
+          },
+          "end": {
+            "line": 48,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "D3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 46,
+            "column": 11
+          },
+          "end": {
+            "line": 46,
+            "column": 13
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 46,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 5
+                },
+                "end": {
+                  "line": 51,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 8
+                },
+                "end": {
+                  "line": 51,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 51,
+                "column": 5
+              },
+              "end": {
+                "line": 51,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 25
+          },
+          "end": {
+            "line": 52,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "D2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 11
+          },
+          "end": {
+            "line": 50,
+            "column": 13
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "D1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 22
+              },
+              "end": {
+                "line": 50,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 25
+            },
+            "end": {
+              "line": 50,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "e",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 5
+                },
+                "end": {
+                  "line": 55,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 55,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 55,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 55,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 55,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 8
+                },
+                "end": {
+                  "line": 55,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 55,
+                "column": 5
+              },
+              "end": {
+                "line": 55,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 33
+          },
+          "end": {
+            "line": 56,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "D5",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 11
+          },
+          "end": {
+            "line": 54,
+            "column": 13
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "D4",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 22
+              },
+              "end": {
+                "line": 54,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 24
+            },
+            "end": {
+              "line": 54,
+              "column": 24
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "D1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 26
+              },
+              "end": {
+                "line": 54,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 28
+            },
+            "end": {
+              "line": 54,
+              "column": 28
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "D3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 30
+              },
+              "end": {
+                "line": 54,
+                "column": 32
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 33
+            },
+            "end": {
+              "line": 54,
+              "column": 32
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 56,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "D5",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 8
+                },
+                "end": {
+                  "line": 58,
+                  "column": 10
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 5
+              },
+              "end": {
+                "line": 58,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 16
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 19
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 19
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 22
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 3,
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 25
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 28
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 35
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 35
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 38
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 41
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 46
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 53
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 55
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 60
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 61
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 61
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "e",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 63
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 64
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 67
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 68
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 70
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 75
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 66
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 76
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 63
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 76
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 13
+              },
+              "end": {
+                "line": 58,
+                "column": 78
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 5
+            },
+            "end": {
+              "line": 58,
+              "column": 78
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 58,
+          "column": 78
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 61,
+                  "column": 5
+                },
+                "end": {
+                  "line": 61,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 61,
+                  "column": 8
+                },
+                "end": {
+                  "line": 61,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 61,
+                "column": 5
+              },
+              "end": {
+                "line": 61,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 60,
+            "column": 13
+          },
+          "end": {
+            "line": 62,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "E",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 60,
+            "column": 11
+          },
+          "end": {
+            "line": 60,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 60,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 5
+                },
+                "end": {
+                  "line": 65,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 8
+                },
+                "end": {
+                  "line": 65,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 65,
+                "column": 5
+              },
+              "end": {
+                "line": 65,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 13
+          },
+          "end": {
+            "line": 66,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "E",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 11
+          },
+          "end": {
+            "line": 64,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 64,
+          "column": 1
+        },
+        "end": {
+          "line": 66,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 5
+                },
+                "end": {
+                  "line": 69,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 69,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 69,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 69,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 69,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 69,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 69,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 69,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 69,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypeLiteral",
+                "members": [],
+                "loc": {
+                  "start": {
+                    "line": 69,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 69,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 8
+                },
+                "end": {
+                  "line": 69,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 5
+              },
+              "end": {
+                "line": 70,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 68,
+            "column": 13
+          },
+          "end": {
+            "line": 70,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "E",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 68,
+            "column": 11
+          },
+          "end": {
+            "line": 68,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 68,
+          "column": 1
+        },
+        "end": {
+          "line": 70,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "E",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 72,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 72,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 72,
+                  "column": 8
+                },
+                "end": {
+                  "line": 72,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 5
+              },
+              "end": {
+                "line": 72,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 72,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 72,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 72,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 72,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 72,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 72,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 72,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 72,
+                      "column": 21
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 72,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 72,
+                      "column": 28
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 72,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 72,
+                    "column": 28
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 72,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 72,
+                      "column": 31
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 72,
+                            "column": 43
+                          },
+                          "end": {
+                            "line": 72,
+                            "column": 44
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 72,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 72,
+                            "column": 47
+                          }
+                        }
+                      }
+                    ],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "ObjectExpression",
+                            "properties": [],
+                            "loc": {
+                              "start": {
+                                "line": 72,
+                                "column": 58
+                              },
+                              "end": {
+                                "line": 72,
+                                "column": 60
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 72,
+                              "column": 51
+                            },
+                            "end": {
+                              "line": 72,
+                              "column": 60
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 72,
+                          "column": 49
+                        },
+                        "end": {
+                          "line": 72,
+                          "column": 62
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 72,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 72,
+                        "column": 62
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 72,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 72,
+                      "column": 62
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 72,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 72,
+                    "column": 62
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 12
+              },
+              "end": {
+                "line": 72,
+                "column": 64
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 72,
+              "column": 5
+            },
+            "end": {
+              "line": 72,
+              "column": 64
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 72,
+          "column": 1
+        },
+        "end": {
+          "line": 72,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 75,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 75,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 75,
+                  "column": 6
+                },
+                "end": {
+                  "line": 75,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 75,
+                  "column": 18
+                },
+                "end": {
+                  "line": 75,
+                  "column": 24
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 75,
+                "column": 5
+              },
+              "end": {
+                "line": 75,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 76,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 76,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 76,
+                  "column": 6
+                },
+                "end": {
+                  "line": 76,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 76,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 76,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 76,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 76,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 76,
+                  "column": 18
+                },
+                "end": {
+                  "line": 76,
+                  "column": 33
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 76,
+                "column": 5
+              },
+              "end": {
+                "line": 77,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 74,
+            "column": 13
+          },
+          "end": {
+            "line": 77,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "F",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 74,
+            "column": 11
+          },
+          "end": {
+            "line": 74,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 74,
+          "column": 1
+        },
+        "end": {
+          "line": 77,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "F",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 79,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 79,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 79,
+                  "column": 8
+                },
+                "end": {
+                  "line": 79,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 79,
+                "column": 5
+              },
+              "end": {
+                "line": 79,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 22
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 79,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 79,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 25
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 32
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 79,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 79,
+                    "column": 32
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 35
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 38
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 79,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 79,
+                    "column": 38
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 41
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 48
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 79,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 79,
+                    "column": 48
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 79,
+                "column": 12
+              },
+              "end": {
+                "line": 79,
+                "column": 50
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 79,
+              "column": 5
+            },
+            "end": {
+              "line": 79,
+              "column": 50
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 79,
+          "column": 1
+        },
+        "end": {
+          "line": 79,
+          "column": 51
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 81,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/interfaceAssignment.ts b/es2panda/test/compiler/ts/interfaceAssignment.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d36ad749d69ad596120c23126c674cd067ee1717
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment.ts
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number,
+    b: string,
+    c: boolean,
+}
+
+var a: A = { a: 1, b: "foo", c: true };
+
+interface B extends A {
+    d(a: number, b: string): number[];
+}
+
+var b: B = {
+    a: 2, b: "bar", c: false, d: function (a: number, b: string) {
+        return [1, 2];
+    }
+}
+
+
+interface C1 {
+    (a: number, b: number): string,
+}
+
+interface C2 {
+    (a: number, b: number): string,
+    (a: number, b: number): string,
+    (a: number, b: number): string,
+}
+
+interface C3 extends C1 {
+    (a: number, b: number): string,
+    (a: number, b: number): string,
+}
+
+var c: C2;
+var c: C3;
+
+interface D4 extends D3, D2 {
+    d: string[]
+}
+
+interface D1 {
+    a: number
+}
+
+interface D3 {
+    c: string,
+}
+
+interface D2 extends D1 {
+    b: number,
+}
+
+interface D5 extends D4, D1, D3 {
+    e: [number, string];
+}
+
+var d: D5 = { a: 2, b: 3, c: "bar", d: ["foo", "bar", "baz"], e: [1, "foo"] }
+
+interface E {
+    a: number,
+}
+
+interface E {
+    b: string,
+}
+
+interface E {
+    d: (a: number, b: string) => {}
+}
+
+var e: E = { a: 1, b: "foo", d: function (a, b) { return {} } }
+
+interface F {
+    [x: number]: string,
+    [x: string]: number | string
+}
+
+var f: F = { 5: "foo", 6: "bar", a: 1, b: "baz" };
+
diff --git a/es2panda/test/compiler/ts/interfaceAssignment1-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4680f0f7864c9d85c350af02d8da5aac52a50c5
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment1-expected.txt
@@ -0,0 +1,325 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 12
+              },
+              "end": {
+                "line": 5,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 20
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 8,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 8
+                },
+                "end": {
+                  "line": 8,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 13
+          },
+          "end": {
+            "line": 9,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 11
+          },
+          "end": {
+            "line": 7,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 10,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '{ a: number; }' is not assignable to type 'A'. [interfaceAssignment1.ts:5:5]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment1.ts b/es2panda/test/compiler/ts/interfaceAssignment1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..85568752ff987834821ee45557541f3d4a712aa5
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment1.ts
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number;
+}
+
+var a: A = { a: 5 };
+
+interface A {
+    b: string;
+}
diff --git a/es2panda/test/compiler/ts/interfaceAssignment2-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..497077c31190f627d6d3160a10644fb141c9f6f7
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment2-expected.txt
@@ -0,0 +1,483 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 8,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 8
+                },
+                "end": {
+                  "line": 8,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 13
+          },
+          "end": {
+            "line": 9,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 5
+            },
+            "end": {
+              "line": 11,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 8
+                },
+                "end": {
+                  "line": 12,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 5
+            },
+            "end": {
+              "line": 12,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 1
+            },
+            "end": {
+              "line": 14,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 1
+          },
+          "end": {
+            "line": 14,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 14,
+      "column": 7
+    }
+  }
+}
+TypeError: Type 'B' is not assignable to type 'A'. [interfaceAssignment2.ts:14:1]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment2.ts b/es2panda/test/compiler/ts/interfaceAssignment2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..835a0e5551c7530a5bdc897823e688eb5a9052a9
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment2.ts
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number,
+    b: string,
+}
+
+interface B {
+    a: string,
+    b: number,
+}
+
+var a: A;
+var b: B;
+
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceAssignment3-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..59a2b706e0ac9956e4d6154a4175520127af415f
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment3-expected.txt
@@ -0,0 +1,771 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 23
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 21
+              },
+              "end": {
+                "line": 5,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 23
+            },
+            "end": {
+              "line": 5,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 5
+                },
+                "end": {
+                  "line": 10,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 23
+          },
+          "end": {
+            "line": 11,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 11
+          },
+          "end": {
+            "line": 9,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 21
+              },
+              "end": {
+                "line": 9,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 23
+            },
+            "end": {
+              "line": 9,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 5
+                },
+                "end": {
+                  "line": 14,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 8
+                },
+                "end": {
+                  "line": 14,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 26
+          },
+          "end": {
+            "line": 15,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "D",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 11
+          },
+          "end": {
+            "line": 13,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "B",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 21
+              },
+              "end": {
+                "line": 13,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 22
+            },
+            "end": {
+              "line": 13,
+              "column": 22
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 24
+              },
+              "end": {
+                "line": 13,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 26
+            },
+            "end": {
+              "line": 13,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "D",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 8
+                },
+                "end": {
+                  "line": 17,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 8
+                },
+                "end": {
+                  "line": 18,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 5
+              },
+              "end": {
+                "line": 18,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 5
+            },
+            "end": {
+              "line": 18,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 5
+            },
+            "end": {
+              "line": 20,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 21,
+      "column": 7
+    }
+  }
+}
+TypeError: Type 'A' is not assignable to type 'D'. [interfaceAssignment3.ts:21:1]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment3.ts b/es2panda/test/compiler/ts/interfaceAssignment3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ec03978f9fb6892f023b9b5c331fa726c6a8ced9
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment3.ts
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number
+}
+
+interface B extends A {
+    b: number,
+}
+
+interface C extends A {
+    c: string
+}
+
+interface D extends B, C {
+    d: [number, number];
+}
+
+var d: D;
+var a: A;
+
+a = d;
+d = a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceAssignment4-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e2ab0e529d475ff01f9529718dbb5af1b02b4b4b
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment4-expected.txt
@@ -0,0 +1,424 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSParenthesizedType",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSBooleanKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 25
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 28
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 29
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 21
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 28
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "NumberLiteral",
+                      "value": 2,
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 38
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 39
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 39
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 12
+              },
+              "end": {
+                "line": 6,
+                "column": 41
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 41
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 42
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 42
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean | string'. [interfaceAssignment4.ts:6:37]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment4.ts b/es2panda/test/compiler/ts/interfaceAssignment4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9da5f305e2b67799ec25317005bed8bcf3e0a925
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment4.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number,
+    b: (boolean | string)[];
+}
+
+var a: A = { a: 1, b: [true, "foo", 2] };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceAssignment5-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a989c51793fb9df30a33808af47aa59f1f0f395
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment5-expected.txt
@@ -0,0 +1,629 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 29
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 21
+              },
+              "end": {
+                "line": 5,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 22
+            },
+            "end": {
+              "line": 5,
+              "column": 22
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 24
+              },
+              "end": {
+                "line": 5,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 25
+            },
+            "end": {
+              "line": 5,
+              "column": 25
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 27
+              },
+              "end": {
+                "line": 5,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 29
+            },
+            "end": {
+              "line": 5,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 5
+                },
+                "end": {
+                  "line": 10,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 29
+          },
+          "end": {
+            "line": 11,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 11
+          },
+          "end": {
+            "line": 9,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "B",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 21
+              },
+              "end": {
+                "line": 9,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 22
+            },
+            "end": {
+              "line": 9,
+              "column": 22
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 24
+              },
+              "end": {
+                "line": 9,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 25
+            },
+            "end": {
+              "line": 9,
+              "column": 25
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "B",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 27
+              },
+              "end": {
+                "line": 9,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 29
+            },
+            "end": {
+              "line": 9,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "C",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 8
+                },
+                "end": {
+                  "line": 13,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 21
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 28
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 12
+              },
+              "end": {
+                "line": 13,
+                "column": 30
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 5
+            },
+            "end": {
+              "line": 13,
+              "column": 30
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 31
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 13,
+      "column": 31
+    }
+  }
+}
+TypeError: Type '{ a: number; c: string; }' is not assignable to type 'C'. [interfaceAssignment5.ts:13:5]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment5.ts b/es2panda/test/compiler/ts/interfaceAssignment5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6ddd75f9d003e3e1d194bde6ea91ceb9ecb6a82b
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment5.ts
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number,
+}
+
+interface B extends A, A, A {
+    b: boolean,
+}
+
+interface C extends B, A, B {
+    c: string
+}
+
+var c: C = { a: 2, c: "foo" };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceAssignment6-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0ce5a7bc0dc17837bfd7223f5f8dea05c3d8b0f7
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment6-expected.txt
@@ -0,0 +1,330 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 18
+                },
+                "end": {
+                  "line": 2,
+                  "column": 24
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 6
+                },
+                "end": {
+                  "line": 3,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 33
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 34
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 22
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 12
+              },
+              "end": {
+                "line": 6,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [interfaceAssignment6.ts:6:14]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment6.ts b/es2panda/test/compiler/ts/interfaceAssignment6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c84dd2e0712cc65c03f5758067c9e8459bf9846e
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment6.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    [x: number]: number,
+    [x: string]: number | string,
+}
+
+var a: A = { 5: "foo" };
diff --git a/es2panda/test/compiler/ts/interfaceAssignment7-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..989a818e713f060457a2b71edcea615b339014c7
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment7-expected.txt
@@ -0,0 +1,411 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 29
+                },
+                "end": {
+                  "line": 2,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 21
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 28
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 12
+              },
+              "end": {
+                "line": 7,
+                "column": 30
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 30
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 31
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 31
+    }
+  }
+}
+TypeError: Type '{ a: number; b: string; }' is not assignable to type 'A'. [interfaceAssignment7.ts:7:5]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment7.ts b/es2panda/test/compiler/ts/interfaceAssignment7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2d275442225f994ffdf9de9adfe21f3ad7ca7360
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment7.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    (a: number, b: string): number,
+    a: number,
+    b: string,
+}
+
+var a: A = { a: 5, b: "foo" };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceAssignment8-expected.txt b/es2panda/test/compiler/ts/interfaceAssignment8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ca53a1b35093d98fc68d8c8c1835bf0dd49f245
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment8-expected.txt
@@ -0,0 +1,417 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 18
+                },
+                "end": {
+                  "line": 2,
+                  "column": 24
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 6
+                },
+                "end": {
+                  "line": 6,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 18
+                },
+                "end": {
+                  "line": 6,
+                  "column": 24
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 13
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 8
+                },
+                "end": {
+                  "line": 9,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 5
+            },
+            "end": {
+              "line": 12,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 12,
+      "column": 7
+    }
+  }
+}
+TypeError: Type 'B' is not assignable to type 'A'. [interfaceAssignment8.ts:12:1]
diff --git a/es2panda/test/compiler/ts/interfaceAssignment8.ts b/es2panda/test/compiler/ts/interfaceAssignment8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..04cd2edb98bf8cb634bf41f08cea9552c9cf6878
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceAssignment8.ts
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    [x: number]: string,
+}
+
+interface B {
+    [x: number]: number,
+}
+
+var a: A;
+var b: B;
+
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceInheritance1-expected.txt b/es2panda/test/compiler/ts/interfaceInheritance1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b31fdec5c333098ac7b54216939dacb5077d4bb7
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance1-expected.txt
@@ -0,0 +1,232 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 23
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 21
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 23
+            },
+            "end": {
+              "line": 1,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 23
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 21
+              },
+              "end": {
+                "line": 5,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 23
+            },
+            "end": {
+              "line": 5,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 23
+          },
+          "end": {
+            "line": 11,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 11
+          },
+          "end": {
+            "line": 9,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "B",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 21
+              },
+              "end": {
+                "line": 9,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 23
+            },
+            "end": {
+              "line": 9,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 2
+    }
+  }
+}
+TypeError: Type 'A' recursively references itself as a base type [interfaceInheritance1.ts:1:11]
diff --git a/es2panda/test/compiler/ts/interfaceInheritance1.ts b/es2panda/test/compiler/ts/interfaceInheritance1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fc7f6dc44e5a090353882cd9eb30ce3608707983
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance1.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A extends C {
+
+}
+
+interface B extends A {
+
+}
+
+interface C extends B {
+
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceInheritance2-expected.txt b/es2panda/test/compiler/ts/interfaceInheritance2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6dcba4f746e40a508390b5e38649d0f5066bae96
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance2-expected.txt
@@ -0,0 +1,221 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 23
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 21
+              },
+              "end": {
+                "line": 5,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 23
+            },
+            "end": {
+              "line": 5,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 2
+    }
+  }
+}
+TypeError: Interface 'B' incorrectly extends interface 'A' [interfaceInheritance2.ts:5:1]
diff --git a/es2panda/test/compiler/ts/interfaceInheritance2.ts b/es2panda/test/compiler/ts/interfaceInheritance2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..791fb1a51a0cabe6970272769d0420cb0de112c8
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance2.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number,
+}
+
+interface B extends A {
+    a: string;
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceInheritance3-expected.txt b/es2panda/test/compiler/ts/interfaceInheritance3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..48f3e0ce1b87e3276756d5d778cdb75f34647683
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance3-expected.txt
@@ -0,0 +1,231 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 18
+                },
+                "end": {
+                  "line": 2,
+                  "column": 24
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 23
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 21
+              },
+              "end": {
+                "line": 5,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 23
+            },
+            "end": {
+              "line": 5,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 2
+    }
+  }
+}
+TypeError: Property '5' of type 'boolean' is not assignable to numeric index type 'number'. [interfaceInheritance3.ts:6:5]
diff --git a/es2panda/test/compiler/ts/interfaceInheritance3.ts b/es2panda/test/compiler/ts/interfaceInheritance3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4f6d752b56b9e8a9527c5da3cfa2aec0831195a0
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance3.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    [x: number]: number,
+}
+
+interface B extends A {
+    5: boolean;
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceInheritance4-expected.txt b/es2panda/test/compiler/ts/interfaceInheritance4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f9a0e9cf031cd8682ce15479d753c739e1fd1c8b
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance4-expected.txt
@@ -0,0 +1,393 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 8,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 8
+                },
+                "end": {
+                  "line": 8,
+                  "column": 17
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 13
+          },
+          "end": {
+            "line": 9,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 26
+          },
+          "end": {
+            "line": 11,
+            "column": 29
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 11
+          },
+          "end": {
+            "line": 11,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 21
+              },
+              "end": {
+                "line": 11,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 22
+            },
+            "end": {
+              "line": 11,
+              "column": 22
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "B",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 24
+              },
+              "end": {
+                "line": 11,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 26
+            },
+            "end": {
+              "line": 11,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 29
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 29
+    }
+  }
+}
+TypeError: Interface 'C' cannot simultaneously extend types 'A' and 'B'. [interfaceInheritance4.ts:11:11]
diff --git a/es2panda/test/compiler/ts/interfaceInheritance4.ts b/es2panda/test/compiler/ts/interfaceInheritance4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0520f0448a1e7d80e006e0d669ad8bb9ae013476
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceInheritance4.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: number,
+    b: string;
+}
+
+interface B {
+    a: string,
+    c: boolean[]
+}
+
+interface C extends A, B { }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface-expected.txt b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c50625026bf7de34b8d6838134e5c0530a7f9cb7
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface-expected.txt
@@ -0,0 +1,1066 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 23
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 21
+              },
+              "end": {
+                "line": 6,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 23
+            },
+            "end": {
+              "line": 6,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 10
+                },
+                "end": {
+                  "line": 10,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "Identifier",
+                    "name": "foo",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 4
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 8
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 8
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 1
+                },
+                "end": {
+                  "line": 12,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 11
+                },
+                "end": {
+                  "line": 12,
+                  "column": 12
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 1
+              },
+              "end": {
+                "line": 12,
+                "column": 12
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 13
+              },
+              "end": {
+                "line": 12,
+                "column": 14
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 14
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 15
+            },
+            "end": {
+              "line": 12,
+              "column": 16
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "MemberExpression",
+                    "object": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 4
+                        }
+                      }
+                    },
+                    "property": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "computed": false,
+                    "optional": false,
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 8
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 12
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 1
+                },
+                "end": {
+                  "line": 13,
+                  "column": 12
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 13
+                },
+                "end": {
+                  "line": 13,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 1
+              },
+              "end": {
+                "line": 13,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 15
+              },
+              "end": {
+                "line": 13,
+                "column": 16
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 1
+            },
+            "end": {
+              "line": 13,
+              "column": 16
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 17
+            },
+            "end": {
+              "line": 13,
+              "column": 18
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 1
+          },
+          "end": {
+            "line": 13,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "MemberExpression",
+                    "object": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 4
+                        }
+                      }
+                    },
+                    "property": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "computed": false,
+                    "optional": false,
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 8
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 12
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 1
+                },
+                "end": {
+                  "line": 14,
+                  "column": 12
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 13
+                },
+                "end": {
+                  "line": 14,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 1
+              },
+              "end": {
+                "line": 14,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 15
+              },
+              "end": {
+                "line": 14,
+                "column": 16
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 1
+            },
+            "end": {
+              "line": 14,
+              "column": 16
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 17
+            },
+            "end": {
+              "line": 14,
+              "column": 18
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 1
+          },
+          "end": {
+            "line": 14,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 15,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface.ts b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1df598ccb3c37b25716a5bc3c2923e468b96a5d0
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface.ts
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: B;
+    b: A;
+}
+
+interface B extends A {
+    c: A;
+}
+
+var foo: B;
+
+foo.a.b.b.a.c.a;
+foo.b.b.b.b.b.b.a;
+foo.c.b.a.c.a.c.a;
diff --git a/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface1-expected.txt b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3350815678882d9b6acbb8fd633ad4ccf1e9fa39
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface1-expected.txt
@@ -0,0 +1,591 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 23
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 21
+              },
+              "end": {
+                "line": 6,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 23
+            },
+            "end": {
+              "line": 6,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 10
+                },
+                "end": {
+                  "line": 10,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "Identifier",
+                    "name": "foo",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 4
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 8
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 8
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 1
+                },
+                "end": {
+                  "line": 12,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 11
+                },
+                "end": {
+                  "line": 12,
+                  "column": 12
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 1
+              },
+              "end": {
+                "line": 12,
+                "column": 12
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 13
+              },
+              "end": {
+                "line": 12,
+                "column": 14
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 14
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "r",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 15
+            },
+            "end": {
+              "line": 12,
+              "column": 16
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 13,
+      "column": 1
+    }
+  }
+}
+TypeError: Property 'r' does not exist on type 'A'. [interfacePropertyReferenceContainingInterface1.ts:12:15]
diff --git a/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface1.ts b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..daf8181897d7b7f24b968538f211215033a0f311
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfacePropertyReferenceContainingInterface1.ts
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a: B;
+    b: A;
+}
+
+interface B extends A {
+    c: A;
+}
+
+var foo: B;
+
+foo.a.b.b.a.c.r
diff --git a/es2panda/test/compiler/ts/interfacePropertyWithIncompatibleIndexInfo-expected.txt b/es2panda/test/compiler/ts/interfacePropertyWithIncompatibleIndexInfo-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f02d3b65a4cc0d8a2c85a3a44e8770952c905206
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfacePropertyWithIncompatibleIndexInfo-expected.txt
@@ -0,0 +1,159 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 18
+                },
+                "end": {
+                  "line": 2,
+                  "column": 25
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 2
+    }
+  }
+}
+TypeError: Property 'a' of type 'string' is not assignable to string index type 'boolean'. [interfacePropertyWithIncompatibleIndexInfo.ts:3:5]
diff --git a/es2panda/test/compiler/ts/interfacePropertyWithIncompatibleIndexInfo.ts b/es2panda/test/compiler/ts/interfacePropertyWithIncompatibleIndexInfo.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e43f9b9796ed5913f4adf3b05b7866855bb4d8a0
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfacePropertyWithIncompatibleIndexInfo.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    [x: string]: boolean,
+    a: string;
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceUsedAsValue-expected.txt b/es2panda/test/compiler/ts/interfaceUsedAsValue-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4b5e4a677cadf4831996324e9fffbe4f98c0c13
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceUsedAsValue-expected.txt
@@ -0,0 +1,362 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSMethodSignature",
+            "computed": false,
+            "optional": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSAnyKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 13
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSAnyKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 21
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 24
+                },
+                "end": {
+                  "line": 3,
+                  "column": 30
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 31
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 29
+                },
+                "end": {
+                  "line": 4,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 37
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 9
+              },
+              "end": {
+                "line": 8,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 11
+    }
+  }
+}
+TypeError: a only refers to a type , but is being used as a value here [interfaceUsedAsValue.ts:8:9]
diff --git a/es2panda/test/compiler/ts/interfaceUsedAsValue.ts b/es2panda/test/compiler/ts/interfaceUsedAsValue.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ba30bdcb34f477af3eb2f6359574b19cc5daf76e
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceUsedAsValue.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: number,
+    b(a: any, b: any): string,
+    (a: number, b: string): boolean,
+    new()
+}
+
+var b = a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/interfaceWithNonCompatibleIndexInfos-expected.txt b/es2panda/test/compiler/ts/interfaceWithNonCompatibleIndexInfos-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..06c0be1643ef55eaa86598b95a6cf28b9c2b50c8
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceWithNonCompatibleIndexInfos-expected.txt
@@ -0,0 +1,170 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 6
+                },
+                "end": {
+                  "line": 2,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 18
+                },
+                "end": {
+                  "line": 2,
+                  "column": 24
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 6
+                },
+                "end": {
+                  "line": 3,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 24
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 25
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Numeric index type 'string' is not assignable to string index type 'number' [interfaceWithNonCompatibleIndexInfos.ts:3:5]
diff --git a/es2panda/test/compiler/ts/interfaceWithNonCompatibleIndexInfos.ts b/es2panda/test/compiler/ts/interfaceWithNonCompatibleIndexInfos.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0977802f42f8333f51f02fa5acf5cb9ed9c3b953
--- /dev/null
+++ b/es2panda/test/compiler/ts/interfaceWithNonCompatibleIndexInfos.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    [x: number]: string,
+    [x: string]: number,
+}
diff --git a/es2panda/test/compiler/ts/interface_enum_member-expected.txt b/es2panda/test/compiler/ts/interface_enum_member-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5a3f380391cb83fdbed6febf57299359768124a2
--- /dev/null
+++ b/es2panda/test/compiler/ts/interface_enum_member-expected.txt
@@ -0,0 +1,205 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSEnumDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "members": [
+        {
+          "type": "TSEnumMember",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "const": false,
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "TSQualifiedName",
+                "left": {
+                  "type": "Identifier",
+                  "name": "A",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 9
+                    }
+                  }
+                },
+                "right": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 2
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 13
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/interface_enum_member.ts b/es2panda/test/compiler/ts/interface_enum_member.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6ce217a3e14d83ddd2c3fb7a50850a0a996acfc0
--- /dev/null
+++ b/es2panda/test/compiler/ts/interface_enum_member.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+enum A {
+    a
+}
+
+interface B {
+    a: A.a
+}
diff --git a/es2panda/test/compiler/ts/letUsedBeforeDeclaration-expected.txt b/es2panda/test/compiler/ts/letUsedBeforeDeclaration-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f7ccfb4ebacbb0398c137422ffc2fa850a827767
--- /dev/null
+++ b/es2panda/test/compiler/ts/letUsedBeforeDeclaration-expected.txt
@@ -0,0 +1,130 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 15
+    }
+  }
+}
+TypeError: Block-scoped variable 'a' used before its declaration [letUsedBeforeDeclaration.ts:1:1]
diff --git a/es2panda/test/compiler/ts/letUsedBeforeDeclaration.ts b/es2panda/test/compiler/ts/letUsedBeforeDeclaration.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4bf17e8b5802616dc9f77eecbc93b26eadf9bd6f
--- /dev/null
+++ b/es2panda/test/compiler/ts/letUsedBeforeDeclaration.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = 2;
+let a: number;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/memberExpTest_1-expected.txt b/es2panda/test/compiler/ts/memberExpTest_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..122ba48c998ef75f8b2683115c28169a211f3844
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_1-expected.txt
@@ -0,0 +1,479 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 1
+                },
+                "end": {
+                  "line": 3,
+                  "column": 4
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 6
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 1
+              },
+              "end": {
+                "line": 3,
+                "column": 13
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 1
+                },
+                "end": {
+                  "line": 4,
+                  "column": 4
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 6
+                },
+                "end": {
+                  "line": 4,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 1
+              },
+              "end": {
+                "line": 5,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 13
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 11
+          },
+          "end": {
+            "line": 2,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 1
+              },
+              "end": {
+                "line": 7,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foo",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 3
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 9
+            },
+            "end": {
+              "line": 7,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 1
+              },
+              "end": {
+                "line": 8,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 3
+              },
+              "end": {
+                "line": 8,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 9
+            },
+            "end": {
+              "line": 8,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 1
+              },
+              "end": {
+                "line": 9,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foobar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 3
+              },
+              "end": {
+                "line": 9,
+                "column": 9
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 1
+            },
+            "end": {
+              "line": 9,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 12
+            },
+            "end": {
+              "line": 9,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 1
+          },
+          "end": {
+            "line": 9,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 9,
+      "column": 14
+    }
+  }
+}
+TypeError: Property 'foobar' does not exist on type 'a'. [memberExpTest_1.ts:9:3]
diff --git a/es2panda/test/compiler/ts/memberExpTest_1.ts b/es2panda/test/compiler/ts/memberExpTest_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cd1affd7e29516a7687de2c5529f9e0054cc7c35
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_1.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface a {
+foo: number,
+bar: string
+}
+var b: a;
+b.foo = 2;
+b.bar = "bar";
+b.foobar = 2;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/memberExpTest_2-expected.txt b/es2panda/test/compiler/ts/memberExpTest_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..abd2e7b8c44385440c9c5b75f157a1efbdeedada
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_2-expected.txt
@@ -0,0 +1,557 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 17
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foobar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 11
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 13
+                },
+                "end": {
+                  "line": 6,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 13
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 8
+                },
+                "end": {
+                  "line": 9,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 1
+              },
+              "end": {
+                "line": 11,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foobar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 3
+              },
+              "end": {
+                "line": 11,
+                "column": 9
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 1
+            },
+            "end": {
+              "line": 11,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 12
+            },
+            "end": {
+              "line": 11,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 1
+          },
+          "end": {
+            "line": 11,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 1
+                },
+                "end": {
+                  "line": 12,
+                  "column": 2
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "foobar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 3
+                },
+                "end": {
+                  "line": 12,
+                  "column": 9
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 1
+              },
+              "end": {
+                "line": 12,
+                "column": 9
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foobar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 10
+              },
+              "end": {
+                "line": 12,
+                "column": 16
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 16
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 19
+            },
+            "end": {
+              "line": 12,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 12,
+      "column": 21
+    }
+  }
+}
+TypeError: Property 'foobar' does not exist on type 'a'. [memberExpTest_2.ts:12:10]
diff --git a/es2panda/test/compiler/ts/memberExpTest_2.ts b/es2panda/test/compiler/ts/memberExpTest_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..08733f93073c16386b2729ad1c511e44d09ede6a
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_2.ts
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    foo: number,
+}
+
+interface b {
+    foobar: a
+}
+
+var c: b;
+var d: a;
+c.foobar = d;
+c.foobar.foobar = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/memberExpTest_3-expected.txt b/es2panda/test/compiler/ts/memberExpTest_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..833b0bb9e83ef64e02aa82678fce7bcc7aacebb4
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_3-expected.txt
@@ -0,0 +1,734 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSParenthesizedType",
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "bar",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 10
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 21
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 22
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 22
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "bar",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 38
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 38
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 38
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 5
+                },
+                "end": {
+                  "line": 5,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 12
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 12
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 11
+                },
+                "end": {
+                  "line": 5,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 13
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 11
+          },
+          "end": {
+            "line": 4,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 8,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 12
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 11
+                },
+                "end": {
+                  "line": 8,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 13
+          },
+          "end": {
+            "line": 9,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "c",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 11
+          },
+          "end": {
+            "line": 7,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a5",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 9
+                },
+                "end": {
+                  "line": 10,
+                  "column": 10
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "Identifier",
+                    "name": "a5",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 3
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "bar",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 4
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 7
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 13
+                  }
+                }
+              },
+              "computed": true,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 1
+                },
+                "end": {
+                  "line": 11,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 15
+                },
+                "end": {
+                  "line": 11,
+                  "column": 16
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 1
+              },
+              "end": {
+                "line": 11,
+                "column": 16
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 17
+              },
+              "end": {
+                "line": 11,
+                "column": 20
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 1
+            },
+            "end": {
+              "line": 11,
+              "column": 20
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 23
+            },
+            "end": {
+              "line": 11,
+              "column": 28
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 1
+          },
+          "end": {
+            "line": 11,
+            "column": 28
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 29
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 29
+    }
+  }
+}
+TypeError: Type 'false' is not assignable to type 'string | number'. [memberExpTest_3.ts:11:1]
diff --git a/es2panda/test/compiler/ts/memberExpTest_3.ts b/es2panda/test/compiler/ts/memberExpTest_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..500fe22fbaa2b798060cc7c85ec623f6ccbf1186
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_3.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: ({bar: string} | {bar: number})
+}
+interface b {
+    foo : a[]
+}
+interface c {
+    bar : b;
+}
+var a5: c;
+a5.bar.foo[0].a.bar = false;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/memberExpTest_4-expected.txt b/es2panda/test/compiler/ts/memberExpTest_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4b307b988e4956ee93860d315cd82edb417a855
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_4-expected.txt
@@ -0,0 +1,468 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 23
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 21
+              },
+              "end": {
+                "line": 6,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 23
+            },
+            "end": {
+              "line": 6,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 1
+              },
+              "end": {
+                "line": 11,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 3
+              },
+              "end": {
+                "line": 11,
+                "column": 4
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 1
+            },
+            "end": {
+              "line": 11,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 7
+            },
+            "end": {
+              "line": 11,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 1
+          },
+          "end": {
+            "line": 11,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 13
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'number'. [memberExpTest_4.ts:11:1]
diff --git a/es2panda/test/compiler/ts/memberExpTest_4.ts b/es2panda/test/compiler/ts/memberExpTest_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..91505bf8bb5dc993c6817c02218e65030f012e9d
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_4.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: number,
+    b: string,
+    c: number,
+}
+interface b extends a {
+    d: number
+}
+
+var c: b;
+c.a = "foo";
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/memberExpTest_5-expected.txt b/es2panda/test/compiler/ts/memberExpTest_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3216555cca0b3f32127b00772515036c3f766f30
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_5-expected.txt
@@ -0,0 +1,468 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 23
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 21
+              },
+              "end": {
+                "line": 6,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 23
+            },
+            "end": {
+              "line": 6,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 1
+              },
+              "end": {
+                "line": 11,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 3
+              },
+              "end": {
+                "line": 11,
+                "column": 4
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 1
+            },
+            "end": {
+              "line": 11,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 7
+            },
+            "end": {
+              "line": 11,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 1
+          },
+          "end": {
+            "line": 11,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 13
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'number'. [memberExpTest_5.ts:11:1]
diff --git a/es2panda/test/compiler/ts/memberExpTest_5.ts b/es2panda/test/compiler/ts/memberExpTest_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dba147aea25e0f035214e9a83bfec73b255c41e7
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_5.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: number,
+    b: string,
+    c: number,
+}
+interface b extends a {
+    d: number
+}
+
+var c: b;
+c.d = "foo";
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/memberExpTest_6-expected.txt b/es2panda/test/compiler/ts/memberExpTest_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..08ba567fdc68562f0f53e1f91a10f115081a9eaf
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_6-expected.txt
@@ -0,0 +1,555 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 7
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 14
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 7
+                },
+                "end": {
+                  "line": 3,
+                  "column": 13
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 23
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 21
+              },
+              "end": {
+                "line": 6,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 23
+            },
+            "end": {
+              "line": 6,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "A",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 9
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "B",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 13
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 1
+            },
+            "end": {
+              "line": 11,
+              "column": 2
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 3
+            },
+            "end": {
+              "line": 11,
+              "column": 4
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 1
+          },
+          "end": {
+            "line": 11,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 5
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 2
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 3
+            },
+            "end": {
+              "line": 12,
+              "column": 4
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 5
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 1
+            },
+            "end": {
+              "line": 13,
+              "column": 2
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 3
+            },
+            "end": {
+              "line": 13,
+              "column": 4
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 1
+          },
+          "end": {
+            "line": 13,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 5
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 13,
+      "column": 5
+    }
+  }
+}
+TypeError: Property 'd' does not exist on type 'A'. [memberExpTest_6.ts:13:3]
diff --git a/es2panda/test/compiler/ts/memberExpTest_6.ts b/es2panda/test/compiler/ts/memberExpTest_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ddaabe4bb605d50d2c23fcf452b9331c8a49f656
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTest_6.ts
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A {
+    a:number,
+    b:string,
+}
+
+interface B extends A {
+    d: string,
+}
+
+var a: A | B;
+a.a;
+a.b;
+a.d;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/memberExpTests-expected.txt b/es2panda/test/compiler/ts/memberExpTests-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a0684526028ff956dc901ec26a9d681758f4c052
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTests-expected.txt
@@ -0,0 +1,5920 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "array1",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 13
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 32
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 35
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 24
+              },
+              "end": {
+                "line": 1,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 36
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "array1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 7
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 3,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 8
+              },
+              "end": {
+                "line": 2,
+                "column": 9
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 13
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 10
+                },
+                "end": {
+                  "line": 6,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 10
+                },
+                "end": {
+                  "line": 7,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 17
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 22
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 5
+                },
+                "end": {
+                  "line": 10,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 10
+                },
+                "end": {
+                  "line": 10,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 5
+                },
+                "end": {
+                  "line": 11,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 10
+                },
+                "end": {
+                  "line": 11,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foobar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 5
+                },
+                "end": {
+                  "line": 12,
+                  "column": 11
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 13
+                },
+                "end": {
+                  "line": 12,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 22
+          },
+          "end": {
+            "line": 13,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 11
+          },
+          "end": {
+            "line": 9,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a1",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 9
+                },
+                "end": {
+                  "line": 14,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b1",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 9
+                },
+                "end": {
+                  "line": 15,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 15,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 5
+            },
+            "end": {
+              "line": 15,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 1
+              },
+              "end": {
+                "line": 16,
+                "column": 3
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foo",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 4
+              },
+              "end": {
+                "line": 16,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 1
+            },
+            "end": {
+              "line": 16,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 10
+            },
+            "end": {
+              "line": 16,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 1
+          },
+          "end": {
+            "line": 16,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 1
+              },
+              "end": {
+                "line": 17,
+                "column": 3
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 4
+              },
+              "end": {
+                "line": 17,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 10
+            },
+            "end": {
+              "line": 17,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "b1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 1
+              },
+              "end": {
+                "line": 18,
+                "column": 3
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foo",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 4
+              },
+              "end": {
+                "line": 18,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 10
+              },
+              "end": {
+                "line": 18,
+                "column": 12
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foo",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 13
+              },
+              "end": {
+                "line": 18,
+                "column": 16
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 10
+            },
+            "end": {
+              "line": 18,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "b1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 3
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 4
+              },
+              "end": {
+                "line": 19,
+                "column": 7
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 10
+              },
+              "end": {
+                "line": 19,
+                "column": 12
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 13
+              },
+              "end": {
+                "line": 19,
+                "column": 16
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 10
+            },
+            "end": {
+              "line": 19,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 1
+              },
+              "end": {
+                "line": 20,
+                "column": 3
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foobar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 4
+              },
+              "end": {
+                "line": 20,
+                "column": 10
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 10
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 13
+            },
+            "end": {
+              "line": 20,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a1",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 1
+                },
+                "end": {
+                  "line": 21,
+                  "column": 3
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "foobar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 4
+                },
+                "end": {
+                  "line": 21,
+                  "column": 10
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 1
+              },
+              "end": {
+                "line": 21,
+                "column": 10
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foo",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 11
+              },
+              "end": {
+                "line": 21,
+                "column": 14
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 14
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 17
+            },
+            "end": {
+              "line": 21,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a1",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 1
+                },
+                "end": {
+                  "line": 22,
+                  "column": 3
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "foobar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 4
+                },
+                "end": {
+                  "line": 22,
+                  "column": 10
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 1
+              },
+              "end": {
+                "line": 22,
+                "column": 10
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 11
+              },
+              "end": {
+                "line": 22,
+                "column": 14
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 14
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 17
+            },
+            "end": {
+              "line": 22,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 5
+                },
+                "end": {
+                  "line": 27,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 10
+                },
+                "end": {
+                  "line": 27,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 22
+          },
+          "end": {
+            "line": 28,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 11
+          },
+          "end": {
+            "line": 26,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a2",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface3",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 9
+                },
+                "end": {
+                  "line": 29,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 29,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a2",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 1
+                },
+                "end": {
+                  "line": 30,
+                  "column": 3
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 4
+                },
+                "end": {
+                  "line": 30,
+                  "column": 7
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 1
+              },
+              "end": {
+                "line": 30,
+                "column": 7
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 8
+              },
+              "end": {
+                "line": 30,
+                "column": 9
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 1
+            },
+            "end": {
+              "line": 30,
+              "column": 10
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 13
+            },
+            "end": {
+              "line": 30,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 1
+          },
+          "end": {
+            "line": 30,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 5
+                },
+                "end": {
+                  "line": 35,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "bar",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 11
+                },
+                "end": {
+                  "line": 35,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 5
+              },
+              "end": {
+                "line": 36,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 22
+          },
+          "end": {
+            "line": 36,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 11
+          },
+          "end": {
+            "line": 34,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a3",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface4",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 9
+                },
+                "end": {
+                  "line": 37,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 5
+              },
+              "end": {
+                "line": 37,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 5
+            },
+            "end": {
+              "line": 37,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a3",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 1
+                },
+                "end": {
+                  "line": 38,
+                  "column": 3
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 4
+                },
+                "end": {
+                  "line": 38,
+                  "column": 7
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 1
+              },
+              "end": {
+                "line": 38,
+                "column": 7
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 8
+              },
+              "end": {
+                "line": 38,
+                "column": 11
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 1
+            },
+            "end": {
+              "line": 38,
+              "column": 11
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 14
+            },
+            "end": {
+              "line": 38,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 1
+          },
+          "end": {
+            "line": 38,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 5
+                },
+                "end": {
+                  "line": 42,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "foobar",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 42,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 42,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 42,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 42,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 42,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 42,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 11
+                },
+                "end": {
+                  "line": 42,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 5
+              },
+              "end": {
+                "line": 43,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 22
+          },
+          "end": {
+            "line": 43,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface5",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 11
+          },
+          "end": {
+            "line": 41,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 43,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 5
+                },
+                "end": {
+                  "line": 45,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "Interface5",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 10
+                },
+                "end": {
+                  "line": 45,
+                  "column": 22
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 46,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 44,
+            "column": 22
+          },
+          "end": {
+            "line": 46,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface6",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 44,
+            "column": 11
+          },
+          "end": {
+            "line": 44,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 44,
+          "column": 1
+        },
+        "end": {
+          "line": 46,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a4",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface6",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 47,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 9
+                },
+                "end": {
+                  "line": 47,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 5
+              },
+              "end": {
+                "line": 47,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 5
+            },
+            "end": {
+              "line": 47,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 47,
+          "column": 1
+        },
+        "end": {
+          "line": 47,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a4",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 48,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 48,
+                      "column": 3
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "bar",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 48,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 48,
+                      "column": 7
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 48,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 48,
+                    "column": 7
+                  }
+                }
+              },
+              "property": {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 48,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 48,
+                    "column": 9
+                  }
+                }
+              },
+              "computed": true,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 1
+                },
+                "end": {
+                  "line": 48,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 11
+                },
+                "end": {
+                  "line": 48,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 1
+              },
+              "end": {
+                "line": 48,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "foobar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 15
+              },
+              "end": {
+                "line": 48,
+                "column": 21
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 48,
+              "column": 1
+            },
+            "end": {
+              "line": 48,
+              "column": 21
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 48,
+              "column": 24
+            },
+            "end": {
+              "line": 48,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 48,
+            "column": 1
+          },
+          "end": {
+            "line": 48,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 48,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 5
+                },
+                "end": {
+                  "line": 52,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSParenthesizedType",
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "bar",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 52,
+                              "column": 10
+                            },
+                            "end": {
+                              "line": 52,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 52,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 52,
+                              "column": 21
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 52,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 52,
+                            "column": 22
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 22
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "bar",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 52,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 52,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 52,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 52,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 52,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 52,
+                            "column": 38
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 38
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 38
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 8
+                },
+                "end": {
+                  "line": 52,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 5
+              },
+              "end": {
+                "line": 53,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 51,
+            "column": 22
+          },
+          "end": {
+            "line": 53,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface6",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 51,
+            "column": 11
+          },
+          "end": {
+            "line": 51,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 51,
+          "column": 1
+        },
+        "end": {
+          "line": 53,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 5
+                },
+                "end": {
+                  "line": 55,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "Interface6",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 55,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 55,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 11
+                },
+                "end": {
+                  "line": 55,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 55,
+                "column": 5
+              },
+              "end": {
+                "line": 56,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 22
+          },
+          "end": {
+            "line": 56,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface7",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 11
+          },
+          "end": {
+            "line": 54,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 56,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 5
+                },
+                "end": {
+                  "line": 58,
+                  "column": 8
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface7",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 11
+                },
+                "end": {
+                  "line": 58,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 5
+              },
+              "end": {
+                "line": 58,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 57,
+            "column": 22
+          },
+          "end": {
+            "line": 59,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface8",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 57,
+            "column": 11
+          },
+          "end": {
+            "line": 57,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 59,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a5",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface8",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 9
+                },
+                "end": {
+                  "line": 60,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 60,
+                "column": 5
+              },
+              "end": {
+                "line": 60,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 5
+            },
+            "end": {
+              "line": 60,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 60,
+          "column": 1
+        },
+        "end": {
+          "line": 60,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "Identifier",
+                    "name": "a5",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 61,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 61,
+                        "column": 3
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "bar",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 61,
+                        "column": 4
+                      },
+                      "end": {
+                        "line": 61,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 61,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 61,
+                      "column": 7
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 61,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 61,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 61,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 61,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 61,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 61,
+                    "column": 13
+                  }
+                }
+              },
+              "computed": true,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 61,
+                  "column": 1
+                },
+                "end": {
+                  "line": 61,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 61,
+                  "column": 15
+                },
+                "end": {
+                  "line": 61,
+                  "column": 16
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 61,
+                "column": 1
+              },
+              "end": {
+                "line": 61,
+                "column": 16
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 61,
+                "column": 17
+              },
+              "end": {
+                "line": 61,
+                "column": 20
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 61,
+              "column": 1
+            },
+            "end": {
+              "line": 61,
+              "column": 20
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 61,
+              "column": 23
+            },
+            "end": {
+              "line": 61,
+              "column": 24
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 61,
+            "column": 1
+          },
+          "end": {
+            "line": 61,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 61,
+          "column": 1
+        },
+        "end": {
+          "line": 61,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "Identifier",
+                    "name": "a5",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 3
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "bar",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 4
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 7
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 62,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 62,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 62,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 62,
+                    "column": 13
+                  }
+                }
+              },
+              "computed": true,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 1
+                },
+                "end": {
+                  "line": 62,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 15
+                },
+                "end": {
+                  "line": 62,
+                  "column": 16
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 62,
+                "column": 1
+              },
+              "end": {
+                "line": 62,
+                "column": 16
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 62,
+                "column": 17
+              },
+              "end": {
+                "line": 62,
+                "column": 20
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 62,
+              "column": 1
+            },
+            "end": {
+              "line": 62,
+              "column": 20
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 62,
+              "column": 23
+            },
+            "end": {
+              "line": 62,
+              "column": 28
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 62,
+            "column": 1
+          },
+          "end": {
+            "line": 62,
+            "column": 28
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 62,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a6",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface8",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 63,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 63,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 9
+                },
+                "end": {
+                  "line": 63,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 63,
+                "column": 5
+              },
+              "end": {
+                "line": 63,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 5
+            },
+            "end": {
+              "line": 63,
+              "column": 7
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 63,
+          "column": 1
+        },
+        "end": {
+          "line": 63,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "Identifier",
+                    "name": "a6",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 64,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 64,
+                        "column": 3
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "bar",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 64,
+                        "column": 4
+                      },
+                      "end": {
+                        "line": 64,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 7
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 64,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 64,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 64,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 64,
+                    "column": 13
+                  }
+                }
+              },
+              "computed": true,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 1
+                },
+                "end": {
+                  "line": 64,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 15
+                },
+                "end": {
+                  "line": 64,
+                  "column": 16
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 1
+              },
+              "end": {
+                "line": 64,
+                "column": 16
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 17
+              },
+              "end": {
+                "line": 64,
+                "column": 20
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 64,
+              "column": 1
+            },
+            "end": {
+              "line": 64,
+              "column": 20
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "MemberExpression",
+                  "object": {
+                    "type": "Identifier",
+                    "name": "a5",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 64,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 64,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "bar",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 64,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 64,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "computed": false,
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 29
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 33
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 64,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 64,
+                    "column": 33
+                  }
+                }
+              },
+              "property": {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 64,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 64,
+                    "column": 35
+                  }
+                }
+              },
+              "computed": true,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 23
+                },
+                "end": {
+                  "line": 64,
+                  "column": 36
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 37
+                },
+                "end": {
+                  "line": 64,
+                  "column": 38
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 23
+              },
+              "end": {
+                "line": 64,
+                "column": 38
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 39
+              },
+              "end": {
+                "line": 64,
+                "column": 42
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 64,
+              "column": 23
+            },
+            "end": {
+              "line": 64,
+              "column": 42
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 1
+          },
+          "end": {
+            "line": 64,
+            "column": 42
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 64,
+          "column": 1
+        },
+        "end": {
+          "line": 64,
+          "column": 43
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 5
+                },
+                "end": {
+                  "line": 68,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 8
+                },
+                "end": {
+                  "line": 68,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 68,
+                "column": 5
+              },
+              "end": {
+                "line": 68,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 5
+                },
+                "end": {
+                  "line": 69,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 8
+                },
+                "end": {
+                  "line": 69,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 5
+              },
+              "end": {
+                "line": 69,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 70,
+                  "column": 5
+                },
+                "end": {
+                  "line": 70,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 70,
+                  "column": 8
+                },
+                "end": {
+                  "line": 70,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 70,
+                "column": 5
+              },
+              "end": {
+                "line": 70,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 67,
+            "column": 22
+          },
+          "end": {
+            "line": 71,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface9",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 67,
+            "column": 11
+          },
+          "end": {
+            "line": 67,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 67,
+          "column": 1
+        },
+        "end": {
+          "line": 71,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 5
+                },
+                "end": {
+                  "line": 73,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 8
+                },
+                "end": {
+                  "line": 73,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 73,
+                "column": 5
+              },
+              "end": {
+                "line": 74,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 72,
+            "column": 42
+          },
+          "end": {
+            "line": 74,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface10",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 72,
+            "column": 11
+          },
+          "end": {
+            "line": 72,
+            "column": 22
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "Interface9",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 31
+              },
+              "end": {
+                "line": 72,
+                "column": 41
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 72,
+              "column": 42
+            },
+            "end": {
+              "line": 72,
+              "column": 41
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 72,
+          "column": 1
+        },
+        "end": {
+          "line": 74,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj13",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Interface10",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 75,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 75,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 75,
+                  "column": 12
+                },
+                "end": {
+                  "line": 75,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 75,
+                "column": 5
+              },
+              "end": {
+                "line": 75,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 75,
+              "column": 5
+            },
+            "end": {
+              "line": 75,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 75,
+          "column": 1
+        },
+        "end": {
+          "line": 75,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "obj13",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 76,
+                "column": 1
+              },
+              "end": {
+                "line": 76,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 76,
+                "column": 7
+              },
+              "end": {
+                "line": 76,
+                "column": 8
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 76,
+              "column": 1
+            },
+            "end": {
+              "line": 76,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 76,
+              "column": 11
+            },
+            "end": {
+              "line": 76,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 76,
+            "column": 1
+          },
+          "end": {
+            "line": 76,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 76,
+          "column": 1
+        },
+        "end": {
+          "line": 76,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "obj13",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 77,
+                "column": 1
+              },
+              "end": {
+                "line": 77,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 77,
+                "column": 7
+              },
+              "end": {
+                "line": 77,
+                "column": 8
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 77,
+              "column": 1
+            },
+            "end": {
+              "line": 77,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 77,
+              "column": 11
+            },
+            "end": {
+              "line": 77,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 77,
+            "column": 1
+          },
+          "end": {
+            "line": 77,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 77,
+          "column": 1
+        },
+        "end": {
+          "line": 77,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "obj13",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 78,
+                "column": 1
+              },
+              "end": {
+                "line": 78,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 78,
+                "column": 7
+              },
+              "end": {
+                "line": 78,
+                "column": 8
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 78,
+              "column": 1
+            },
+            "end": {
+              "line": 78,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 78,
+              "column": 11
+            },
+            "end": {
+              "line": 78,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 78,
+            "column": 1
+          },
+          "end": {
+            "line": 78,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 78,
+          "column": 1
+        },
+        "end": {
+          "line": 78,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "obj13",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 79,
+                "column": 1
+              },
+              "end": {
+                "line": 79,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 79,
+                "column": 7
+              },
+              "end": {
+                "line": 79,
+                "column": 8
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 79,
+              "column": 1
+            },
+            "end": {
+              "line": 79,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 79,
+              "column": 11
+            },
+            "end": {
+              "line": 79,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 79,
+            "column": 1
+          },
+          "end": {
+            "line": 79,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 79,
+          "column": 1
+        },
+        "end": {
+          "line": 79,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj14",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 80,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 80,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 80,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 80,
+                              "column": 23
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 80,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 80,
+                            "column": 25
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSTupleType",
+                        "elementTypes": [
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 80,
+                                "column": 29
+                              },
+                              "end": {
+                                "line": 80,
+                                "column": 36
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 80,
+                                "column": 37
+                              },
+                              "end": {
+                                "line": 80,
+                                "column": 44
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 80,
+                                "column": 45
+                              },
+                              "end": {
+                                "line": 80,
+                                "column": 52
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 80,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 80,
+                            "column": 52
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 80,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 80,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 80,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 80,
+                      "column": 53
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 80,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 80,
+                        "column": 55
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 80,
+                              "column": 59
+                            },
+                            "end": {
+                              "line": 80,
+                              "column": 65
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 80,
+                            "column": 59
+                          },
+                          "end": {
+                            "line": 80,
+                            "column": 67
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 80,
+                          "column": 56
+                        },
+                        "end": {
+                          "line": 80,
+                          "column": 57
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 80,
+                          "column": 70
+                        },
+                        "end": {
+                          "line": 80,
+                          "column": 76
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 80,
+                        "column": 70
+                      },
+                      "end": {
+                        "line": 80,
+                        "column": 78
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 80,
+                      "column": 54
+                    },
+                    "end": {
+                      "line": 80,
+                      "column": 80
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 80,
+                  "column": 12
+                },
+                "end": {
+                  "line": 80,
+                  "column": 80
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 80,
+                "column": 5
+              },
+              "end": {
+                "line": 80,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 80,
+              "column": 5
+            },
+            "end": {
+              "line": 80,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 80,
+          "column": 1
+        },
+        "end": {
+          "line": 80,
+          "column": 81
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "obj14",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 81,
+                "column": 1
+              },
+              "end": {
+                "line": 81,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 81,
+                "column": 7
+              },
+              "end": {
+                "line": 81,
+                "column": 8
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 81,
+              "column": 1
+            },
+            "end": {
+              "line": 81,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 81,
+                  "column": 12
+                },
+                "end": {
+                  "line": 81,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 81,
+                  "column": 15
+                },
+                "end": {
+                  "line": 81,
+                  "column": 16
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 3,
+              "loc": {
+                "start": {
+                  "line": 81,
+                  "column": 18
+                },
+                "end": {
+                  "line": 81,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 81,
+              "column": 11
+            },
+            "end": {
+              "line": 81,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 81,
+            "column": 1
+          },
+          "end": {
+            "line": 81,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 81,
+          "column": 1
+        },
+        "end": {
+          "line": 81,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "obj14",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 82,
+                "column": 1
+              },
+              "end": {
+                "line": 82,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 82,
+                "column": 7
+              },
+              "end": {
+                "line": 82,
+                "column": 8
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 82,
+              "column": 1
+            },
+            "end": {
+              "line": 82,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 12
+                },
+                "end": {
+                  "line": 82,
+                  "column": 17
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 19
+                },
+                "end": {
+                  "line": 82,
+                  "column": 24
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 26
+                },
+                "end": {
+                  "line": 82,
+                  "column": 31
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 82,
+              "column": 11
+            },
+            "end": {
+              "line": 82,
+              "column": 32
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 82,
+            "column": 1
+          },
+          "end": {
+            "line": 82,
+            "column": 32
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 82,
+          "column": 1
+        },
+        "end": {
+          "line": 82,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "obj14",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 83,
+                "column": 1
+              },
+              "end": {
+                "line": 83,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 83,
+                "column": 7
+              },
+              "end": {
+                "line": 83,
+                "column": 8
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 83,
+              "column": 1
+            },
+            "end": {
+              "line": 83,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "FunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": false,
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSParenthesizedType",
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 83,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 83,
+                          "column": 31
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 83,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 83,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 83,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 83,
+                      "column": 34
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 83,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 83,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "body": {
+              "type": "BlockStatement",
+              "statements": [
+                {
+                  "type": "ReturnStatement",
+                  "argument": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 83,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 83,
+                            "column": 51
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 83,
+                            "column": 53
+                          },
+                          "end": {
+                            "line": 83,
+                            "column": 58
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 83,
+                            "column": 60
+                          },
+                          "end": {
+                            "line": 83,
+                            "column": 65
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 83,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 83,
+                        "column": 66
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 83,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 83,
+                      "column": 66
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 83,
+                  "column": 36
+                },
+                "end": {
+                  "line": 83,
+                  "column": 68
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 83,
+                "column": 11
+              },
+              "end": {
+                "line": 83,
+                "column": 68
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 83,
+              "column": 11
+            },
+            "end": {
+              "line": 83,
+              "column": 68
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 83,
+            "column": 1
+          },
+          "end": {
+            "line": 83,
+            "column": 68
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 83,
+          "column": 1
+        },
+        "end": {
+          "line": 83,
+          "column": 69
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 86,
+                  "column": 5
+                },
+                "end": {
+                  "line": 86,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 86,
+                  "column": 8
+                },
+                "end": {
+                  "line": 86,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 86,
+                "column": 5
+              },
+              "end": {
+                "line": 86,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 85,
+            "column": 23
+          },
+          "end": {
+            "line": 87,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface11",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 85,
+            "column": 11
+          },
+          "end": {
+            "line": 85,
+            "column": 22
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 85,
+          "column": 1
+        },
+        "end": {
+          "line": 87,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj15",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "Interface10",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 89,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 89,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 89,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 89,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "Interface11",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 89,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 89,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 89,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 89,
+                      "column": 37
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 89,
+                  "column": 12
+                },
+                "end": {
+                  "line": 89,
+                  "column": 37
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 89,
+                "column": 5
+              },
+              "end": {
+                "line": 89,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 89,
+              "column": 5
+            },
+            "end": {
+              "line": 89,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 89,
+          "column": 1
+        },
+        "end": {
+          "line": 89,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "Identifier",
+          "name": "obj15",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 90,
+              "column": 1
+            },
+            "end": {
+              "line": 90,
+              "column": 6
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 90,
+              "column": 7
+            },
+            "end": {
+              "line": 90,
+              "column": 8
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 90,
+            "column": 1
+          },
+          "end": {
+            "line": 90,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 90,
+          "column": 1
+        },
+        "end": {
+          "line": 90,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj16",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 92,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 92,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 92,
+                              "column": 28
+                            },
+                            "end": {
+                              "line": 92,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 92,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 92,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 92,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 92,
+                            "column": 39
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 92,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 92,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 92,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 92,
+                      "column": 41
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 92,
+                  "column": 12
+                },
+                "end": {
+                  "line": 92,
+                  "column": 41
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 92,
+                "column": 5
+              },
+              "end": {
+                "line": 92,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 92,
+              "column": 5
+            },
+            "end": {
+              "line": 92,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 92,
+          "column": 1
+        },
+        "end": {
+          "line": 92,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "obj16",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 93,
+                  "column": 1
+                },
+                "end": {
+                  "line": 93,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 93,
+                  "column": 7
+                },
+                "end": {
+                  "line": 93,
+                  "column": 8
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 93,
+                "column": 1
+              },
+              "end": {
+                "line": 93,
+                "column": 8
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 93,
+                "column": 9
+              },
+              "end": {
+                "line": 93,
+                "column": 10
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 93,
+              "column": 1
+            },
+            "end": {
+              "line": 93,
+              "column": 10
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 93,
+              "column": 13
+            },
+            "end": {
+              "line": 93,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 93,
+            "column": 1
+          },
+          "end": {
+            "line": 93,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 93,
+          "column": 1
+        },
+        "end": {
+          "line": 93,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 93,
+      "column": 15
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/memberExpTests.ts b/es2panda/test/compiler/ts/memberExpTests.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99eea3d891df95b108869eaf8e3e6843663a1b9a
--- /dev/null
+++ b/es2panda/test/compiler/ts/memberExpTests.ts
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var array1: number[] = [1, 2, 3, 4];
+array1[3] = 5;
+
+
+interface Interface1 {
+    foo: number,
+    bar: string,
+}
+interface Interface2 {
+    foo: number,
+    bar: string,
+    foobar: Interface1
+}
+var a1: Interface2;
+var b1: Interface1;
+a1.foo = 2;
+a1.bar = "bar";
+b1.foo = a1.foo;
+b1.bar = a1.bar;
+a1.foobar = b1;
+a1.foobar.foo = 3;
+a1.foobar.bar = "foo";
+
+
+
+interface Interface3 {
+    foo: number[]
+}
+var a2: Interface3;
+a2.foo[2] = 5;
+
+
+
+interface Interface4 {
+    foo : {bar: number}
+}
+var a3: Interface4;
+a3.foo.bar = 3;
+
+
+interface Interface5 {
+    foo : {foobar: number}
+}
+interface Interface6 {
+    bar: Interface5[]
+}
+var a4: Interface6;
+a4.bar[0].foo.foobar = 3;
+
+
+interface Interface6 {
+    a: ({bar: string} | {bar: number})
+}
+interface Interface7 {
+    foo : Interface6[]
+}
+interface Interface8 {
+    bar : Interface7;
+}
+var a5: Interface8;
+a5.bar.foo[0].a.bar = 5;
+a5.bar.foo[0].a.bar = "foo";
+var a6: Interface8;
+a6.bar.foo[1].a.bar = a5.bar.foo[0].a.bar;
+
+
+interface Interface9 {
+    a: number,
+    b: string,
+    c: number,
+}
+interface Interface10 extends Interface9 {
+    d: number
+}
+var obj13: Interface10;
+obj13.a = 5;
+obj13.b = "foo";
+obj13.c = 5;
+obj13.d = 5;
+var obj14: { a: number[] | [string, string, string], b(a: number[]): string[] };
+obj14.a = [1, 2, 3];
+obj14.a = ["foo", "bar", "baz"];
+obj14.b = function (a: (number[])) { return ["foo", "bar", "baz"] };
+
+interface Interface11 {
+    a: number,
+}
+
+var obj15: Interface10 | Interface11;
+obj15.a;
+
+var obj16: { readonly a: { b: number } };
+obj16.a.b = 3;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/member_expression_1-expected.txt b/es2panda/test/compiler/ts/member_expression_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e51fdba14cb390e9a362be5569921fdf4f9d0584
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_1-expected.txt
@@ -0,0 +1,420 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "baz",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 15
+              },
+              "end": {
+                "line": 3,
+                "column": 18
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_1.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_1.ts b/es2panda/test/compiler/ts/member_expression_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0f8d2a20205baed641853fda16fea2eba9841de6
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_10-expected.txt b/es2panda/test/compiler/ts/member_expression_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e41bad7cd40a2f11ef06ef7ee7155c326abf3f8e
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_10-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_10.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_10.ts b/es2panda/test/compiler/ts/member_expression_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..893d8b0262cc3a8d0f01b9611a9575b40a2c35f4
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a?.foo.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_11-expected.txt b/es2panda/test/compiler/ts/member_expression_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7a00cdb3a435772bdcafa22e710f72192bed2de3
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_11-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_11.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_11.ts b/es2panda/test/compiler/ts/member_expression_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..45652e7a9a0978d074d4331cdb6701214d41ec3d
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a?.foo.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_12-expected.txt b/es2panda/test/compiler/ts/member_expression_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..54885999ba99a24912f6429c605f5cada99cf0e9
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_12-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_12.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_12.ts b/es2panda/test/compiler/ts/member_expression_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..93e8bcd0a48b25161f40dd497b27bc372439f9e5
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a?.foo?.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_13-expected.txt b/es2panda/test/compiler/ts/member_expression_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d37c6e6312cdf094df9b2f0dfcb8dd961ead82a8
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_13-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 19
+                },
+                "end": {
+                  "line": 3,
+                  "column": 24
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_13.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_13.ts b/es2panda/test/compiler/ts/member_expression_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c145228f86ee06b740609bc1292042fd5d294ab
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_13.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a?.foo?.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_14-expected.txt b/es2panda/test/compiler/ts/member_expression_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5ef2e83b6e71f02e2f19a5d0b1a39d0c94753111
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_14-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_14.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_14.ts b/es2panda/test/compiler/ts/member_expression_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c964ae9a344b692d13304998e3d6ad47b132cae9
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_14.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a?.foo.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_15-expected.txt b/es2panda/test/compiler/ts/member_expression_15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b6289567e79a29a1126e3635e6f48ac5e358d496
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_15-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_15.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_15.ts b/es2panda/test/compiler/ts/member_expression_15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2c0adc221551bf34262cc8ae8acc51d061ff7288
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_15.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a?.foo.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_16-expected.txt b/es2panda/test/compiler/ts/member_expression_16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..099fddac58ea9a15391f3196aada94da550f8fec
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_16-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_16.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_16.ts b/es2panda/test/compiler/ts/member_expression_16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0de7f5f206cbbe788ef0f844fc301c802d8180bc
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_16.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a?.foo?.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_17-expected.txt b/es2panda/test/compiler/ts/member_expression_17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41558ced0cae5a1def77630f2a4d7926a1b98594
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_17-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 19
+                },
+                "end": {
+                  "line": 3,
+                  "column": 24
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_17.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_17.ts b/es2panda/test/compiler/ts/member_expression_17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c1527dbf5647af81037be240542d95e9f9101460
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_17.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a?.foo?.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_18-expected.txt b/es2panda/test/compiler/ts/member_expression_18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d8978a0793f983c6da6876f094f58ccfef6c855f
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_18-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_18.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_18.ts b/es2panda/test/compiler/ts/member_expression_18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..680c704304144c1eeb951bc20e2649da98f78188
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_18.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a?.foo.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_19-expected.txt b/es2panda/test/compiler/ts/member_expression_19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..81a062352d2f8725dd3d6f155ddb35f4b82a3fb0
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_19-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_19.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_19.ts b/es2panda/test/compiler/ts/member_expression_19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8995e9abd8dea0435cf7b264867f11614522b0f3
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_19.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a?.foo.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_2-expected.txt b/es2panda/test/compiler/ts/member_expression_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4514dda596c4ec915f2c5f1bc333b1ba151019f
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_2-expected.txt
@@ -0,0 +1,419 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 15
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_2.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_2.ts b/es2panda/test/compiler/ts/member_expression_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e6f14e03f9f83eb6b78e76706dceddca9f071025
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_20-expected.txt b/es2panda/test/compiler/ts/member_expression_20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..12edcf24e58b9b06866d39443de5c9555ea028aa
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_20-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_20.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_20.ts b/es2panda/test/compiler/ts/member_expression_20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e47e11509c15778e1e72e1cacd9674eb9a96d3d
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_20.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a?.foo?.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_21-expected.txt b/es2panda/test/compiler/ts/member_expression_21-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f6055a3861b51bbdb3cbba3c95e7aa16c1dbf824
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_21-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 19
+                },
+                "end": {
+                  "line": 3,
+                  "column": 24
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_21.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_21.ts b/es2panda/test/compiler/ts/member_expression_21.ts
new file mode 100644
index 0000000000000000000000000000000000000000..95e7fa1e0ffcdc9c30a6b9508e6f80198b34fc8a
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_21.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a?.foo?.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_22-expected.txt b/es2panda/test/compiler/ts/member_expression_22-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..daebfdc03f20fe15d52edefb800e89283e8ce7e3
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_22-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_22.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_22.ts b/es2panda/test/compiler/ts/member_expression_22.ts
new file mode 100644
index 0000000000000000000000000000000000000000..facb989707e435be7b715fa0d9cbaf3798270ba4
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_22.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo?.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_23-expected.txt b/es2panda/test/compiler/ts/member_expression_23-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2029e5f9578b5c1cfef683dfe922d3b000e4e579
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_23-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_23.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_23.ts b/es2panda/test/compiler/ts/member_expression_23.ts
new file mode 100644
index 0000000000000000000000000000000000000000..003cf5002bf73285f8e8020f4ea1b149616b5fd8
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_23.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo?.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_24-expected.txt b/es2panda/test/compiler/ts/member_expression_24-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cdd3431979d499e71e4e9da2832d5af25ff88886
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_24-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_24.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_24.ts b/es2panda/test/compiler/ts/member_expression_24.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ff137c9ec7c18a0367bcbd4530b37ce9d9de78d7
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_24.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo?.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_25-expected.txt b/es2panda/test/compiler/ts/member_expression_25-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d1f837985c0044e6a9ba5abfca3ef8e45b9f1e2
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_25-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 23
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 24
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_25.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_25.ts b/es2panda/test/compiler/ts/member_expression_25.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fcbbe8ad64f38031cc0c6e67e091f6577ae8d2ae
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_25.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo?.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_26-expected.txt b/es2panda/test/compiler/ts/member_expression_26-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0c04dc3627542df24d96da321e6a67232374a766
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_26-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_26.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_26.ts b/es2panda/test/compiler/ts/member_expression_26.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f93ebad13372ef3bcd6717231ed981ca5437595c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_26.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo?.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_27-expected.txt b/es2panda/test/compiler/ts/member_expression_27-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..329912b523dcd84b9049c6d18050baf7ed3ae2f1
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_27-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_27.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_27.ts b/es2panda/test/compiler/ts/member_expression_27.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7cfb0e9438d80139b5ac8369fd09c509d1bf51c1
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_27.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo?.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_28-expected.txt b/es2panda/test/compiler/ts/member_expression_28-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..250b0c6ba02ef0460791a3c30ba067d675dafb2c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_28-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_28.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_28.ts b/es2panda/test/compiler/ts/member_expression_28.ts
new file mode 100644
index 0000000000000000000000000000000000000000..657db5ab152260b291fbf7bdcd68a9d565a1606b
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_28.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo?.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_29-expected.txt b/es2panda/test/compiler/ts/member_expression_29-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0ad84babd3e11853b8884d7fd7f88bd238b42f0c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_29-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 23
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 24
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_29.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_29.ts b/es2panda/test/compiler/ts/member_expression_29.ts
new file mode 100644
index 0000000000000000000000000000000000000000..30c99239aa1c14ff729959af765fd7daa8bd6e48
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_29.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo?.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_3-expected.txt b/es2panda/test/compiler/ts/member_expression_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..12d8e5036acbd37c54f2bea61302fcc783d84e50
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_3-expected.txt
@@ -0,0 +1,420 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "baz",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 15
+              },
+              "end": {
+                "line": 3,
+                "column": 18
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_3.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_3.ts b/es2panda/test/compiler/ts/member_expression_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..10d0cd8dcb7f0f3e99c4b52fc7b18ceff5e765d6
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_30-expected.txt b/es2panda/test/compiler/ts/member_expression_30-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0b84ff6d570bb46ab2be85e9c2ef900dc32c50b2
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_30-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_30.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_30.ts b/es2panda/test/compiler/ts/member_expression_30.ts
new file mode 100644
index 0000000000000000000000000000000000000000..db0d7b088dd9f1231a2c4ddba59a5e00794d36a7
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_30.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo?.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_31-expected.txt b/es2panda/test/compiler/ts/member_expression_31-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..29268b67bd4884b75e513fcb3d4bcbb7c53716d5
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_31-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_31.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_31.ts b/es2panda/test/compiler/ts/member_expression_31.ts
new file mode 100644
index 0000000000000000000000000000000000000000..796817ea61bb37907d04b6137daeb1dcb6f779ba
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_31.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo?.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_32-expected.txt b/es2panda/test/compiler/ts/member_expression_32-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..396713245a240b20bfcffdbc8ffff59cfbc1550d
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_32-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_32.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_32.ts b/es2panda/test/compiler/ts/member_expression_32.ts
new file mode 100644
index 0000000000000000000000000000000000000000..172bd39f32fc1d5c758ff2fbaa3812c9a44f9bee
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_32.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo?.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_33-expected.txt b/es2panda/test/compiler/ts/member_expression_33-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..656ed1ae9e215cd3fe090643a5e17fed91230d2e
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_33-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 23
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 24
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_33.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_33.ts b/es2panda/test/compiler/ts/member_expression_33.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2375b7b8bdb1a3e1e77ef8bbb3158a78d28835f4
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_33.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo?.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_34-expected.txt b/es2panda/test/compiler/ts/member_expression_34-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e074b70be5a35427f27a999f3f06fa270c3a3189
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_34-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 14
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_34.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_34.ts b/es2panda/test/compiler/ts/member_expression_34.ts
new file mode 100644
index 0000000000000000000000000000000000000000..06a8674a81940bc77f30e08525a85fa9062b1286
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_34.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_35-expected.txt b/es2panda/test/compiler/ts/member_expression_35-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1482b9bb1731d1b5baabcdd82b802e0f2f6111b7
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_35-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 14
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 22
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_35.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_35.ts b/es2panda/test/compiler/ts/member_expression_35.ts
new file mode 100644
index 0000000000000000000000000000000000000000..41dcf41d363f44788bc51d1a78c9f623be6c828a
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_35.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a.foo.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_36-expected.txt b/es2panda/test/compiler/ts/member_expression_36-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2c02e4e990721b067c83c489d5894a701e0b5f0e
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_36-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_36.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_36.ts b/es2panda/test/compiler/ts/member_expression_36.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c88306b2b3cc0e95f047b3ef314044848204506
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_36.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a?.foo?.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_37-expected.txt b/es2panda/test/compiler/ts/member_expression_37-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..599902518613909fc350a88aa84fab78b8b1f24c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_37-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 22
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_37.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_37.ts b/es2panda/test/compiler/ts/member_expression_37.ts
new file mode 100644
index 0000000000000000000000000000000000000000..db7fde0e283a5f27c4e3fa8f27863228e24e3e22
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_37.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: string;
+b = a?.foo?.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_38-expected.txt b/es2panda/test/compiler/ts/member_expression_38-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..831d9976e9970b8c23a85701f1b743be508f0367
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_38-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 14
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_38.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_38.ts b/es2panda/test/compiler/ts/member_expression_38.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e3e46fe79d3f7dc51f8994b336a573f6f57b58e7
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_38.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_39-expected.txt b/es2panda/test/compiler/ts/member_expression_39-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3e3b0265146a7aaca342e67b85865d7b03b9ce16
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_39-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 14
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 22
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_39.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_39.ts b/es2panda/test/compiler/ts/member_expression_39.ts
new file mode 100644
index 0000000000000000000000000000000000000000..495b45dbef05ffb04dfc3e16b82c7a494412ba5f
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_39.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_4-expected.txt b/es2panda/test/compiler/ts/member_expression_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ee70f673e617194ee29988d5cac3675489c3be28
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_4-expected.txt
@@ -0,0 +1,419 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 15
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_4.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_4.ts b/es2panda/test/compiler/ts/member_expression_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5c0689a8ff929763df81d106fdcb9af2c5620818
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a.foo.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_40-expected.txt b/es2panda/test/compiler/ts/member_expression_40-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ba0d1821a8ad4dee683c55f2eca21b6f10e69939
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_40-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_40.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_40.ts b/es2panda/test/compiler/ts/member_expression_40.ts
new file mode 100644
index 0000000000000000000000000000000000000000..70a9ae3ab9bc54c11c25807b34cfb37807e0225c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_40.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a?.foo?.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_41-expected.txt b/es2panda/test/compiler/ts/member_expression_41-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9af70ff770614ba31734f607b26b476302031a2a
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_41-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 22
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_41.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_41.ts b/es2panda/test/compiler/ts/member_expression_41.ts
new file mode 100644
index 0000000000000000000000000000000000000000..31b6435b7e6a2ab900007e3b0688d62a5cefc832
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_41.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: bigint;
+b = a?.foo?.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_42-expected.txt b/es2panda/test/compiler/ts/member_expression_42-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..062e5a4ee246afa1e060bcf04dda3c5866e8c5e6
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_42-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 14
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_42.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_42.ts b/es2panda/test/compiler/ts/member_expression_42.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a7ff909d71afc2adea16d329c7ada03409c120eb
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_42.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo.bar?.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_43-expected.txt b/es2panda/test/compiler/ts/member_expression_43-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a05e7155d9e99319fb2bae3be96930e08990f8ec
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_43-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 14
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 22
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_43.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_43.ts b/es2panda/test/compiler/ts/member_expression_43.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3749debef07c343864cbdeeb3d823611a83d9459
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_43.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo.bar?.['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_44-expected.txt b/es2panda/test/compiler/ts/member_expression_44-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..35a14938cb958914171eb90a6f885ac14736c798
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_44-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_44.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_44.ts b/es2panda/test/compiler/ts/member_expression_44.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1e07729faf14b4cd62c3f541c57717abd9a9972c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_44.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a?.foo?.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_45-expected.txt b/es2panda/test/compiler/ts/member_expression_45-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8182337bac031eac1269436d86211fb3b634e7de
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_45-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 22
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_45.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_45.ts b/es2panda/test/compiler/ts/member_expression_45.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9ae13e38d3d616963157d47689f94961f33b3ece
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_45.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a?.foo?.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_46-expected.txt b/es2panda/test/compiler/ts/member_expression_46-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..da2ef9da655d036640cdbe8be97625c3da07d6de
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_46-expected.txt
@@ -0,0 +1,289 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 7
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_46.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_46.ts b/es2panda/test/compiler/ts/member_expression_46.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1e3ea3675e03365dd64422b4d898af6f572f7479
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_46.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: string;
+b = a[0];
diff --git a/es2panda/test/compiler/ts/member_expression_47-expected.txt b/es2panda/test/compiler/ts/member_expression_47-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c131025a240b23323e506848ca7d7b7dc692f5b
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_47-expected.txt
@@ -0,0 +1,302 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 0,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_47.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_47.ts b/es2panda/test/compiler/ts/member_expression_47.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d478002148592557654a7720ac3898bc47e268b0
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_47.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: string;
+b = a?.[0];
diff --git a/es2panda/test/compiler/ts/member_expression_48-expected.txt b/es2panda/test/compiler/ts/member_expression_48-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..55fab14d3136df0e1b98f02fc01a663576e14ea2
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_48-expected.txt
@@ -0,0 +1,289 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 7
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_48.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_48.ts b/es2panda/test/compiler/ts/member_expression_48.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e30b1cc9793bf51575424f525c6791642ee55c19
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_48.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: string;
+b = a[5];
diff --git a/es2panda/test/compiler/ts/member_expression_49-expected.txt b/es2panda/test/compiler/ts/member_expression_49-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d4a9b19ca51e67eece79c681819331434e052e4b
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_49-expected.txt
@@ -0,0 +1,302 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_49.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_49.ts b/es2panda/test/compiler/ts/member_expression_49.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5752dab5004e236c94182c2241b2ef76c180250b
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_49.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: string;
+b = a?.[5];
diff --git a/es2panda/test/compiler/ts/member_expression_5-expected.txt b/es2panda/test/compiler/ts/member_expression_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4b9cc3c6c9aa7ae93df5e9005ad06a010f3f6cf
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_5-expected.txt
@@ -0,0 +1,420 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "baz",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 15
+              },
+              "end": {
+                "line": 3,
+                "column": 18
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_5.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_5.ts b/es2panda/test/compiler/ts/member_expression_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5ef8be8c52bb50a4236f9e93b0686867a371c841
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo.bar.baz;
diff --git a/es2panda/test/compiler/ts/member_expression_50-expected.txt b/es2panda/test/compiler/ts/member_expression_50-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3c0fc035c4b298a5071a89a103391344078f8d0c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_50-expected.txt
@@ -0,0 +1,376 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 7
+                },
+                "end": {
+                  "line": 4,
+                  "column": 8
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 11
+                },
+                "end": {
+                  "line": 4,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 7
+              },
+              "end": {
+                "line": 4,
+                "column": 12
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_50.ts:4:1]
diff --git a/es2panda/test/compiler/ts/member_expression_50.ts b/es2panda/test/compiler/ts/member_expression_50.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6ea8553bf56fef40b114ad19f24218b50e6f0548
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_50.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: string;
+var c: number;
+b = a[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_51-expected.txt b/es2panda/test/compiler/ts/member_expression_51-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..940c5c25d9e0b76164c409d0748d17918ab5c81b
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_51-expected.txt
@@ -0,0 +1,389 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [member_expression_51.ts:4:1]
diff --git a/es2panda/test/compiler/ts/member_expression_51.ts b/es2panda/test/compiler/ts/member_expression_51.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9ad1d2b72f061fd43e5ca5c2b235132c5982b4c5
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_51.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: string;
+var c: number;
+b = a?.[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_52-expected.txt b/es2panda/test/compiler/ts/member_expression_52-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dd295c6cc5cd16dedbf1766366a03bba320d6dc6
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_52-expected.txt
@@ -0,0 +1,376 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 7
+                },
+                "end": {
+                  "line": 4,
+                  "column": 8
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 11
+                },
+                "end": {
+                  "line": 4,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 7
+              },
+              "end": {
+                "line": 4,
+                "column": 12
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'string'. [member_expression_52.ts:4:7]
diff --git a/es2panda/test/compiler/ts/member_expression_52.ts b/es2panda/test/compiler/ts/member_expression_52.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f13970efef0197658787d23c8144648d2b9f08ad
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_52.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: number;
+var c: string;
+b = a[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_53-expected.txt b/es2panda/test/compiler/ts/member_expression_53-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..981b99edd9d211f21a2acabb15612da778420ca9
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_53-expected.txt
@@ -0,0 +1,389 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'string'. [member_expression_53.ts:4:9]
diff --git a/es2panda/test/compiler/ts/member_expression_53.ts b/es2panda/test/compiler/ts/member_expression_53.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8abd324225111cb52bfaadfb17308f7d76de26f0
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_53.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: number;
+var c: string;
+b = a?.[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_54-expected.txt b/es2panda/test/compiler/ts/member_expression_54-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..851928a31dd61e73a07c61a369a065021665a04c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_54-expected.txt
@@ -0,0 +1,289 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 7
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_54.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_54.ts b/es2panda/test/compiler/ts/member_expression_54.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6195bd1ad54527a240721c0330812f3a58ed2dbe
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_54.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: bigint;
+b = a[0];
diff --git a/es2panda/test/compiler/ts/member_expression_55-expected.txt b/es2panda/test/compiler/ts/member_expression_55-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..80b13e02d42c16429e7501b1cd51612d7468f61a
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_55-expected.txt
@@ -0,0 +1,302 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 0,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_55.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_55.ts b/es2panda/test/compiler/ts/member_expression_55.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6bdde65f3db8c28916f38b23389698374a270f1f
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_55.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: bigint;
+b = a?.[0];
diff --git a/es2panda/test/compiler/ts/member_expression_56-expected.txt b/es2panda/test/compiler/ts/member_expression_56-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..396eb3ea5e2b86411a2c47a71491063755fb2904
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_56-expected.txt
@@ -0,0 +1,289 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 7
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_56.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_56.ts b/es2panda/test/compiler/ts/member_expression_56.ts
new file mode 100644
index 0000000000000000000000000000000000000000..77ce0626b31bca7dadc8eeb6e36eeb2998fddc44
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_56.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: bigint;
+b = a[5];
diff --git a/es2panda/test/compiler/ts/member_expression_57-expected.txt b/es2panda/test/compiler/ts/member_expression_57-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7ee757d4a4ec806e04ae7df5d5a0d450543796aa
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_57-expected.txt
@@ -0,0 +1,302 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_57.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_57.ts b/es2panda/test/compiler/ts/member_expression_57.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4f33187fda8b5941d7da396fbf618a3caf66cec4
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_57.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: bigint;
+b = a?.[5];
diff --git a/es2panda/test/compiler/ts/member_expression_58-expected.txt b/es2panda/test/compiler/ts/member_expression_58-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..91564ba3f8e4dc64cb0b8990bdac0b85a6e19762
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_58-expected.txt
@@ -0,0 +1,376 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 7
+                },
+                "end": {
+                  "line": 4,
+                  "column": 8
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 11
+                },
+                "end": {
+                  "line": 4,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 7
+              },
+              "end": {
+                "line": 4,
+                "column": 12
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_58.ts:4:1]
diff --git a/es2panda/test/compiler/ts/member_expression_58.ts b/es2panda/test/compiler/ts/member_expression_58.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f9b45a9ca9665982a0fa50068ca8026f0b48bf4d
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_58.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: bigint;
+var c: number;
+b = a[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_59-expected.txt b/es2panda/test/compiler/ts/member_expression_59-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..632769447e5598e4b915af4c023f3d8a14e42063
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_59-expected.txt
@@ -0,0 +1,389 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'bigint'. [member_expression_59.ts:4:1]
diff --git a/es2panda/test/compiler/ts/member_expression_59.ts b/es2panda/test/compiler/ts/member_expression_59.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a36691c4f5ac91bf73f8a6703915888def3b2bb
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_59.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: bigint;
+var c: number;
+b = a?.[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_6-expected.txt b/es2panda/test/compiler/ts/member_expression_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b5a1eb46b36e5a455f358a373550af463c79910f
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_6-expected.txt
@@ -0,0 +1,419 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 15
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_6.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_6.ts b/es2panda/test/compiler/ts/member_expression_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a1d4987e66289f899186926f9acabf196c4bf7f6
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_6.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: boolean;
+b = a.foo.bar['baz'];
diff --git a/es2panda/test/compiler/ts/member_expression_60-expected.txt b/es2panda/test/compiler/ts/member_expression_60-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8ee08ea1466bb508c4478fd5625147287b5ee051
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_60-expected.txt
@@ -0,0 +1,376 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 7
+                },
+                "end": {
+                  "line": 4,
+                  "column": 8
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 11
+                },
+                "end": {
+                  "line": 4,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 7
+              },
+              "end": {
+                "line": 4,
+                "column": 12
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [member_expression_60.ts:4:7]
diff --git a/es2panda/test/compiler/ts/member_expression_60.ts b/es2panda/test/compiler/ts/member_expression_60.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a8ca9131cc571b8cccddddab30e9d16d74dc6b8d
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_60.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: number;
+var c: bigint;
+b = a[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_61-expected.txt b/es2panda/test/compiler/ts/member_expression_61-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..662a90a6fd4914bc2c1aee433246fa72fa2d4f11
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_61-expected.txt
@@ -0,0 +1,389 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'bigint'. [member_expression_61.ts:4:9]
diff --git a/es2panda/test/compiler/ts/member_expression_61.ts b/es2panda/test/compiler/ts/member_expression_61.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ce4c20ec14ee44ae3751f61082ad9695de5f0ed4
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_61.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: number;
+var c: bigint;
+b = a?.[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_62-expected.txt b/es2panda/test/compiler/ts/member_expression_62-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..628f825b707a57cbd106ab012a11f2a866bf358a
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_62-expected.txt
@@ -0,0 +1,289 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 7
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_62.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_62.ts b/es2panda/test/compiler/ts/member_expression_62.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7deb30cd88c7caf74c104020764d2e0f828d2c42
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_62.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: boolean;
+b = a[0];
diff --git a/es2panda/test/compiler/ts/member_expression_63-expected.txt b/es2panda/test/compiler/ts/member_expression_63-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b4552fdd12ce1f999dc4f72ef63589846be60b0
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_63-expected.txt
@@ -0,0 +1,302 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 0,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_63.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_63.ts b/es2panda/test/compiler/ts/member_expression_63.ts
new file mode 100644
index 0000000000000000000000000000000000000000..487f0e8bcb023abcd5cbd180b074824cdb1f498e
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_63.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: boolean;
+b = a?.[0];
diff --git a/es2panda/test/compiler/ts/member_expression_64-expected.txt b/es2panda/test/compiler/ts/member_expression_64-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b569d1a418c8e2394bc800e7274603935c6e6fc0
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_64-expected.txt
@@ -0,0 +1,289 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 7
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_64.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_64.ts b/es2panda/test/compiler/ts/member_expression_64.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dc5d28486ee6a17e0e589629111d7f1efd7d1b7a
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_64.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: boolean;
+b = a[5];
diff --git a/es2panda/test/compiler/ts/member_expression_65-expected.txt b/es2panda/test/compiler/ts/member_expression_65-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fbde617e2976a86366c8b650b4b59ab6b19845f5
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_65-expected.txt
@@ -0,0 +1,302 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_65.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_65.ts b/es2panda/test/compiler/ts/member_expression_65.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5558efd9ee26351d1c998c00bdb42b122bb804f2
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_65.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: boolean;
+b = a?.[5];
diff --git a/es2panda/test/compiler/ts/member_expression_66-expected.txt b/es2panda/test/compiler/ts/member_expression_66-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41637141505508069becc19422a5060f160913a4
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_66-expected.txt
@@ -0,0 +1,376 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 7
+                },
+                "end": {
+                  "line": 4,
+                  "column": 8
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 11
+                },
+                "end": {
+                  "line": 4,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 7
+              },
+              "end": {
+                "line": 4,
+                "column": 12
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_66.ts:4:1]
diff --git a/es2panda/test/compiler/ts/member_expression_66.ts b/es2panda/test/compiler/ts/member_expression_66.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2620614e64a4dfb8749a7433c094d150b08513e8
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_66.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: boolean;
+var c: number;
+b = a[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_67-expected.txt b/es2panda/test/compiler/ts/member_expression_67-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c9dcddc3cbe045265090a8236f3245366cb28259
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_67-expected.txt
@@ -0,0 +1,389 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean'. [member_expression_67.ts:4:1]
diff --git a/es2panda/test/compiler/ts/member_expression_67.ts b/es2panda/test/compiler/ts/member_expression_67.ts
new file mode 100644
index 0000000000000000000000000000000000000000..306baef53997452447146889d9a391e638bddc55
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_67.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: boolean;
+var c: number;
+b = a?.[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_68-expected.txt b/es2panda/test/compiler/ts/member_expression_68-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..da85cd82b93e4293fdec1b691ee2eb5d33c43fd7
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_68-expected.txt
@@ -0,0 +1,376 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "property": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 7
+                },
+                "end": {
+                  "line": 4,
+                  "column": 8
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 11
+                },
+                "end": {
+                  "line": 4,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 7
+              },
+              "end": {
+                "line": 4,
+                "column": 12
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'boolean'. [member_expression_68.ts:4:7]
diff --git a/es2panda/test/compiler/ts/member_expression_68.ts b/es2panda/test/compiler/ts/member_expression_68.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c17463e6a444ef3caafac82c6776884594995d5
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_68.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: number;
+var c: boolean;
+b = a[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_69-expected.txt b/es2panda/test/compiler/ts/member_expression_69-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cf3cf9717dd9bbc4d461e2ea375b405c445c08ac
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_69-expected.txt
@@ -0,0 +1,389 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "property": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "computed": true,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'boolean'. [member_expression_69.ts:4:9]
diff --git a/es2panda/test/compiler/ts/member_expression_69.ts b/es2panda/test/compiler/ts/member_expression_69.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3ad9f56b54efe11cbe53988f975e3f229000ac17
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_69.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+var b: number;
+var c: boolean;
+b = a?.[c = 5];
diff --git a/es2panda/test/compiler/ts/member_expression_7-expected.txt b/es2panda/test/compiler/ts/member_expression_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5c66bd65589606da4491f9d50b0bcf49b0f5ec53
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_7-expected.txt
@@ -0,0 +1,420 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 11
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "bad",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 15
+              },
+              "end": {
+                "line": 3,
+                "column": 18
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Property 'bad' does not exist on type '{ baz: number; }'. [member_expression_7.ts:3:15]
diff --git a/es2panda/test/compiler/ts/member_expression_7.ts b/es2panda/test/compiler/ts/member_expression_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..93cde439ee354c09145155a7e02af1f7c2819de6
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: number;
+b = a.foo.bar.bad;
diff --git a/es2panda/test/compiler/ts/member_expression_70-expected.txt b/es2panda/test/compiler/ts/member_expression_70-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c36d1ade991022d9799a888909721cfa69e01bba
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_70-expected.txt
@@ -0,0 +1,271 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "readonly": true,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 36
+                    }
+                  }
+                },
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 40
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "readonly": false,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 55
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 56
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 3
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Index signature in type '{ [b: string]: number; readonly [a: number]: number; }' only permits reading. [member_expression_70.ts:2:1]
diff --git a/es2panda/test/compiler/ts/member_expression_70.ts b/es2panda/test/compiler/ts/member_expression_70.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1b06eadee0291345c580e4fec8f9101781797038
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_70.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: {readonly [a:number]:number, [b:string]:number};
+a[5] = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_71-expected.txt b/es2panda/test/compiler/ts/member_expression_71-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e14151724c055d51fea46cca6e566a033175ac83
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_71-expected.txt
@@ -0,0 +1,271 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 18
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "readonly": false,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 40
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "readonly": true,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 55
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 56
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 3
+              },
+              "end": {
+                "line": 2,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 12
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Index signature in type '{ readonly [b: string]: number; [a: number]: number; }' only permits reading. [member_expression_71.ts:2:1]
diff --git a/es2panda/test/compiler/ts/member_expression_71.ts b/es2panda/test/compiler/ts/member_expression_71.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2555b5f35ce99e7d56ddf873f1627a92a33f709e
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_71.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: {[a:number]:number, readonly [b:string]:number};
+a["foo"] = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_72-expected.txt b/es2panda/test/compiler/ts/member_expression_72-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bf31d7b09cd9fa2b5a0f39967dfc489efd165027
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_72-expected.txt
@@ -0,0 +1,328 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "a",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 34
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 26
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 36
+                },
+                "end": {
+                  "line": 1,
+                  "column": 42
+                }
+              }
+            },
+            "readonly": true,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 16
+              },
+              "end": {
+                "line": 1,
+                "column": 43
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "b",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 25
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 27
+                },
+                "end": {
+                  "line": 2,
+                  "column": 33
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 16
+              },
+              "end": {
+                "line": 2,
+                "column": 34
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 15
+          },
+          "end": {
+            "line": 2,
+            "column": 35
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 1
+              },
+              "end": {
+                "line": 5,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 3
+              },
+              "end": {
+                "line": 5,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 8
+            },
+            "end": {
+              "line": 5,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Index signature in type 'foo' only permits reading. [member_expression_72.ts:5:1]
diff --git a/es2panda/test/compiler/ts/member_expression_72.ts b/es2panda/test/compiler/ts/member_expression_72.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c339a02af45861747303e7268c58f87417fc0ec2
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_72.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface foo {readonly [a:number]:number,
+               [b:string]:number,}
+
+var a: foo;
+a[5] = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_73-expected.txt b/es2panda/test/compiler/ts/member_expression_73-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..111cd3646b74205b7367b082fad589152d5e2e8d
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_73-expected.txt
@@ -0,0 +1,328 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "a",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 25
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 18
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 27
+                },
+                "end": {
+                  "line": 1,
+                  "column": 33
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 16
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "b",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 34
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 26
+                },
+                "end": {
+                  "line": 2,
+                  "column": 27
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 36
+                },
+                "end": {
+                  "line": 2,
+                  "column": 42
+                }
+              }
+            },
+            "readonly": true,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 16
+              },
+              "end": {
+                "line": 2,
+                "column": 43
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 15
+          },
+          "end": {
+            "line": 2,
+            "column": 44
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "foo",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 1
+              },
+              "end": {
+                "line": 5,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 3
+              },
+              "end": {
+                "line": 5,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 12
+            },
+            "end": {
+              "line": 5,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Index signature in type 'foo' only permits reading. [member_expression_73.ts:5:1]
diff --git a/es2panda/test/compiler/ts/member_expression_73.ts b/es2panda/test/compiler/ts/member_expression_73.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dbb599fda8ed35d5800caffb7a0c0abd80a86833
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_73.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface foo {[a:number]:number,
+               readonly [b:string]:number,}
+
+var a: foo;
+a["foo"] = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_74-expected.txt b/es2panda/test/compiler/ts/member_expression_74-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c61cd86268aa1d49ff4c7ecb4f67ceecd7a13ce8
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_74-expected.txt
@@ -0,0 +1,282 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": true,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 32
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 34
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 40
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 41
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 42
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 42
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 43
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 2
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 3
+                },
+                "end": {
+                  "line": 2,
+                  "column": 4
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 9
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to 'c' because it is a read-only property. [member_expression_74.ts:2:5]
diff --git a/es2panda/test/compiler/ts/member_expression_74.ts b/es2panda/test/compiler/ts/member_expression_74.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3bc0d7e9dba97993aaa63f0262b4a12ca1afa712
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_74.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: {readonly b: {readonly c: number}};
+a.b.c = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_75-expected.txt b/es2panda/test/compiler/ts/member_expression_75-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9b7bdf2df604f97377b24238d3255ca99d75a30a
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_75-expected.txt
@@ -0,0 +1,339 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": true,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 14
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 15
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 1
+                },
+                "end": {
+                  "line": 6,
+                  "column": 2
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 3
+                },
+                "end": {
+                  "line": 6,
+                  "column": 4
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 1
+              },
+              "end": {
+                "line": 6,
+                "column": 4
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 9
+            },
+            "end": {
+              "line": 6,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to 'c' because it is a read-only property. [member_expression_75.ts:6:5]
diff --git a/es2panda/test/compiler/ts/member_expression_75.ts b/es2panda/test/compiler/ts/member_expression_75.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c64c558a2aba7e4d2905f6a4ee9f69bcf4db65c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_75.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface foo {
+    readonly c: number,
+}
+
+var a: {readonly b: foo};
+a.b.c = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_76-expected.txt b/es2panda/test/compiler/ts/member_expression_76-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65f4625732b95c4825c75a2bcf70693264b4393f
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_76-expected.txt
@@ -0,0 +1,339 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": true,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 14
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 15
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 15
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 16
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 1
+                },
+                "end": {
+                  "line": 6,
+                  "column": 2
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 3
+                },
+                "end": {
+                  "line": 6,
+                  "column": 4
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 1
+              },
+              "end": {
+                "line": 6,
+                "column": 4
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 9
+            },
+            "end": {
+              "line": 6,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to 'c' because it is a read-only property. [member_expression_76.ts:6:5]
diff --git a/es2panda/test/compiler/ts/member_expression_76.ts b/es2panda/test/compiler/ts/member_expression_76.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99dcffba15d8920d355c7260f4618bf12dbedd14
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_76.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface foo {
+    readonly c: number,
+}
+
+var a: {b: foo};
+a.b.c = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_77-expected.txt b/es2panda/test/compiler/ts/member_expression_77-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cf430a873db8e839ad090773dd63d36b8dd62d8b
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_77-expected.txt
@@ -0,0 +1,282 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": true,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 22
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 23
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 31
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 33
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 34
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 1
+                },
+                "end": {
+                  "line": 2,
+                  "column": 2
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 3
+                },
+                "end": {
+                  "line": 2,
+                  "column": 4
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 4
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 9
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Cannot assign to 'c' because it is a read-only property. [member_expression_77.ts:2:5]
diff --git a/es2panda/test/compiler/ts/member_expression_77.ts b/es2panda/test/compiler/ts/member_expression_77.ts
new file mode 100644
index 0000000000000000000000000000000000000000..175e181b93033da41371fa4deb139c016fdf5d8e
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_77.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: {b: {readonly c: number}};
+a.b.c = 5;
diff --git a/es2panda/test/compiler/ts/member_expression_78-expected.txt b/es2panda/test/compiler/ts/member_expression_78-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2f8e3612f9080e6752efc30804035a1e71ab3089
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_78-expected.txt
@@ -0,0 +1,335 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 9
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "SpreadElement",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "o",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 9
+                },
+                "end": {
+                  "line": 5,
+                  "column": 15
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 19
+                },
+                "end": {
+                  "line": 5,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 9
+              },
+              "end": {
+                "line": 5,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 1
+              },
+              "end": {
+                "line": 6,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 3
+              },
+              "end": {
+                "line": 6,
+                "column": 4
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 7
+            },
+            "end": {
+              "line": 6,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 9
+    }
+  }
+}
+TypeError: Cannot assign to 'a' because it is a read-only property. [member_expression_78.ts:6:3]
diff --git a/es2panda/test/compiler/ts/member_expression_78.ts b/es2panda/test/compiler/ts/member_expression_78.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e975056ef3202f890ea656c37128777a34f41de4
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_78.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var o = {
+    a: 1,
+}
+
+var a = {...o} as const;
+a.a = 1;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/member_expression_79-expected.txt b/es2panda/test/compiler/ts/member_expression_79-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8caee4d032ef8aaa3b6cfadc0d0bbd227f597b32
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_79-expected.txt
@@ -0,0 +1,391 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "o",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "o",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "SpreadElement",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 9
+                },
+                "end": {
+                  "line": 6,
+                  "column": 15
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 19
+                },
+                "end": {
+                  "line": 6,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 9
+              },
+              "end": {
+                "line": 6,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 1
+              },
+              "end": {
+                "line": 7,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 3
+              },
+              "end": {
+                "line": 7,
+                "column": 4
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 7
+            },
+            "end": {
+              "line": 7,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 9
+    }
+  }
+}
+TypeError: Cannot assign to 'a' because it is a read-only property. [member_expression_79.ts:7:3]
diff --git a/es2panda/test/compiler/ts/member_expression_79.ts b/es2panda/test/compiler/ts/member_expression_79.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9ce21ad4475fc3c464c85c81beed80adc7a4e346
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_79.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface o {
+    a: number;
+}
+
+var a: o;
+var b = {...a} as const;
+b.a = 2;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/member_expression_8-expected.txt b/es2panda/test/compiler/ts/member_expression_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7e00d59a654a0240cc162d481020eb4ef8665764
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_8-expected.txt
@@ -0,0 +1,433 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 11
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 16
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "bad",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "computed": false,
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Property 'bad' does not exist on type '{ baz: number; }'. [member_expression_8.ts:3:18]
diff --git a/es2panda/test/compiler/ts/member_expression_8.ts b/es2panda/test/compiler/ts/member_expression_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..95dee3f2ff1d4219080f973241e960c2662c4ade
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: number;
+b = a?.foo?.bar?.bad;
diff --git a/es2panda/test/compiler/ts/member_expression_80-expected.txt b/es2panda/test/compiler/ts/member_expression_80-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f09f34e23285b5c305bc00095fcafa3bd85c01e
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_80-expected.txt
@@ -0,0 +1,274 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": true,
+                  "key": {
+                    "type": "BinaryExpression",
+                    "operator": "+",
+                    "left": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 12
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "NumberLiteral",
+                      "value": 4,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 20
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 24
+                },
+                "end": {
+                  "line": 1,
+                  "column": 29
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 30
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 30
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 1
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 3
+              },
+              "end": {
+                "line": 3,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 8
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 10
+    }
+  }
+}
+TypeError: Index signature in type '{ readonly [x: number]: 3; }' only permits reading. [member_expression_80.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_80.ts b/es2panda/test/compiler/ts/member_expression_80.ts
new file mode 100644
index 0000000000000000000000000000000000000000..69c9264b75b07a6068b6b8381243b61fd3a309aa
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_80.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {[5 + 4]:3} as const;
+
+a[5] = 3;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/member_expression_81-expected.txt b/es2panda/test/compiler/ts/member_expression_81-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..12913e5918b69526c28480990b9137bdfbe625b2
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_81-expected.txt
@@ -0,0 +1,275 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": true,
+                  "key": {
+                    "type": "BinaryExpression",
+                    "operator": "+",
+                    "left": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 35
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 30
+                },
+                "end": {
+                  "line": 1,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 36
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 1
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "baz",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 3
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 9
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 11
+    }
+  }
+}
+TypeError: Index signature in type '{ readonly [x: string]: 3; }' only permits reading. [member_expression_81.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_81.ts b/es2panda/test/compiler/ts/member_expression_81.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e215f516b874fbd1c8b198464aa986fa437a168
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_81.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {["foo"+"bar"]:3} as const;
+
+a.baz = 3;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/member_expression_82-expected.txt b/es2panda/test/compiler/ts/member_expression_82-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ebf2f71425b9623e97ccda084fd3204190840d4b
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_82-expected.txt
@@ -0,0 +1,274 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": true,
+                  "key": {
+                    "type": "BinaryExpression",
+                    "operator": "+",
+                    "left": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 35
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 30
+                },
+                "end": {
+                  "line": 1,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 36
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 1
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 3
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 12
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 14
+    }
+  }
+}
+TypeError: Index signature in type '{ readonly [x: string]: 3; }' only permits reading. [member_expression_82.ts:3:1]
diff --git a/es2panda/test/compiler/ts/member_expression_82.ts b/es2panda/test/compiler/ts/member_expression_82.ts
new file mode 100644
index 0000000000000000000000000000000000000000..afdd029ad82d8a5fc12006bd120e9dc806bf472d
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_82.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {["foo"+"bar"]:3} as const;
+
+a["baz"] = 3;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/member_expression_9-expected.txt b/es2panda/test/compiler/ts/member_expression_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b46d4804e8610484fccf1ed5c1dc1956842d9d06
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_9-expected.txt
@@ -0,0 +1,432 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "bar",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [
+                          {
+                            "type": "Property",
+                            "method": false,
+                            "shorthand": false,
+                            "computed": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "baz",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "value": {
+                              "type": "NumberLiteral",
+                              "value": 5,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "kind": "init",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 31
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ChainExpression",
+          "expression": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "MemberExpression",
+                "object": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 6
+                    }
+                  }
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 10
+                    }
+                  }
+                },
+                "computed": false,
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 15
+                  }
+                }
+              },
+              "computed": false,
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "baz",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/member_expression_9.ts b/es2panda/test/compiler/ts/member_expression_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d9ad8adee184430adfe502d54463f7e1859c7a6c
--- /dev/null
+++ b/es2panda/test/compiler/ts/member_expression_9.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+var b: number;
+b = a.foo?.bar.baz;
diff --git a/es2panda/test/compiler/ts/new_expression_1-expected.txt b/es2panda/test/compiler/ts/new_expression_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..808c980e2318a01c2ababdb401ee0dbba5a69c77
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_1-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_1.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_1.ts b/es2panda/test/compiler/ts/new_expression_1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..189e8de6a86b00100d02e43764a0d53a7f7540ff
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_1.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: string): any ;};
+var a = new foo("foo",5);
diff --git a/es2panda/test/compiler/ts/new_expression_10-expected.txt b/es2panda/test/compiler/ts/new_expression_10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9288a1a4d0c1595469aee94e771c437677057462
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_10-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_10.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_10.ts b/es2panda/test/compiler/ts/new_expression_10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8c3770a0657309791bf0336a3e0a1a1b26ff665e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_10.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: number): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_100-expected.txt b/es2panda/test/compiler/ts/new_expression_100-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a6ce2ac0f6c22c5ad4c5c51a2e784299047ff6e1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_100-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [new_expression_100.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_100.ts b/es2panda/test/compiler/ts/new_expression_100.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8d0ad64be375f8aee26be076e45725c5c342f436
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_100.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: number) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_101-expected.txt b/es2panda/test/compiler/ts/new_expression_101-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..67fcc24c8a15d1e4e8f00830c4c19bdd6ce0ff8c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_101-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_101.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_101.ts b/es2panda/test/compiler/ts/new_expression_101.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dae5dc94ec7cd52cc8f72aef0d05b3801faabba2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_101.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: number) => any;
+var a = new foo("foo",false);
diff --git a/es2panda/test/compiler/ts/new_expression_102-expected.txt b/es2panda/test/compiler/ts/new_expression_102-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9bc7ee391a19da865d60a4b5f951eba994be67fe
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_102-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_102.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_102.ts b/es2panda/test/compiler/ts/new_expression_102.ts
new file mode 100644
index 0000000000000000000000000000000000000000..857cb7dc898eb80b75e13210eeaa1c063a48cf4f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_102.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: number) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_103-expected.txt b/es2panda/test/compiler/ts/new_expression_103-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..13f7f8bfa870072c0608ba5ab60e5c0324769da8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_103-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_103.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_103.ts b/es2panda/test/compiler/ts/new_expression_103.ts
new file mode 100644
index 0000000000000000000000000000000000000000..462502413272bc7e5d0b036f9dcc34a47b096d73
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_103.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: number) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_104-expected.txt b/es2panda/test/compiler/ts/new_expression_104-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3603bb160d8dcba2c9337e820eda9676b16b3b50
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_104-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_104.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_104.ts b/es2panda/test/compiler/ts/new_expression_104.ts
new file mode 100644
index 0000000000000000000000000000000000000000..582cf2bb66184f80a6c560532760f5e5b6381e24
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_104.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: number) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_105-expected.txt b/es2panda/test/compiler/ts/new_expression_105-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3489f44a6b50b4f8f1d59d3eab17876801356cb
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_105-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_105.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_105.ts b/es2panda/test/compiler/ts/new_expression_105.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99d578c4b9d3018eb41137ee89902d71046fcd30
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_105.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: number) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_106-expected.txt b/es2panda/test/compiler/ts/new_expression_106-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d92957413bc78efecb021698ade8058de4599f5
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_106-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_106.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_106.ts b/es2panda/test/compiler/ts/new_expression_106.ts
new file mode 100644
index 0000000000000000000000000000000000000000..465025103d28df9db62f4d01a0fd21c02f6def87
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_106.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: number) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_107-expected.txt b/es2panda/test/compiler/ts/new_expression_107-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b270ad80a5b03bcb48fe333e75d00641c8e0052b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_107-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'boolean'. [new_expression_107.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_107.ts b/es2panda/test/compiler/ts/new_expression_107.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7ec08c7fcb702dc6cf06122f5d766f87e20a1913
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_107.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: boolean) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_108-expected.txt b/es2panda/test/compiler/ts/new_expression_108-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a38d284b9811420236bc52e5ca3894f326fdc664
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_108-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_108.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_108.ts b/es2panda/test/compiler/ts/new_expression_108.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f64b1b84c8f9051a35673e5facce17cce706317c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_108.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: boolean) => any;
+var a = new foo("foo",5);
diff --git a/es2panda/test/compiler/ts/new_expression_109-expected.txt b/es2panda/test/compiler/ts/new_expression_109-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..215e48acc79657c8cacdcdf9b62724a336ef9579
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_109-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_109.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_109.ts b/es2panda/test/compiler/ts/new_expression_109.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56a8d1a3f0ccd1be97a9eac762adc57132fbe3e0
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_109.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: boolean) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_11-expected.txt b/es2panda/test/compiler/ts/new_expression_11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ed6db5e718c678d33b02efb0174184c9ec903794
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_11-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_11.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_11.ts b/es2panda/test/compiler/ts/new_expression_11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3b52957cc55d0191785fe1cb175bbccd73531266
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_11.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: number): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_110-expected.txt b/es2panda/test/compiler/ts/new_expression_110-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bfb195a1c2efac8946d688f42d34da9fe05fb57a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_110-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_110.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_110.ts b/es2panda/test/compiler/ts/new_expression_110.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e5ae7580b6e9249a961e810b30933d85aba3c55e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_110.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: boolean) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_111-expected.txt b/es2panda/test/compiler/ts/new_expression_111-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..513c802f6d41bd1636e56ffea2e50329c50fa55e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_111-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_111.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_111.ts b/es2panda/test/compiler/ts/new_expression_111.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb116c247baa34f096b395701deba8ee3934f199
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_111.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: boolean) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_112-expected.txt b/es2panda/test/compiler/ts/new_expression_112-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c563d65d816fad3bcd5814275e3db859f5d62144
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_112-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_112.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_112.ts b/es2panda/test/compiler/ts/new_expression_112.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fc01bfc2f2a204b331d69929ff83048de9a7655a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_112.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: boolean) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_113-expected.txt b/es2panda/test/compiler/ts/new_expression_113-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9ee35ac82dfbfbc08ed2caeaeb366b940a77df7e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_113-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_113.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_113.ts b/es2panda/test/compiler/ts/new_expression_113.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d7926a7a44784b61c0b046feb0269872ba9cdbad
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_113.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: boolean) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_114-expected.txt b/es2panda/test/compiler/ts/new_expression_114-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..08a7e3d7e8a938b2d644c2f837d1990908d00306
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_114-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [new_expression_114.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_114.ts b/es2panda/test/compiler/ts/new_expression_114.ts
new file mode 100644
index 0000000000000000000000000000000000000000..578f20163e4baf32c6f6c3430e67704bf16e6cba
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_114.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: string) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_115-expected.txt b/es2panda/test/compiler/ts/new_expression_115-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7825fea7d9420f42dd335d57cde6c0bcc3eca80d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_115-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_115.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_115.ts b/es2panda/test/compiler/ts/new_expression_115.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b6711fc596d66779e1924647364993d9f4aa2e1c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_115.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: string) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_116-expected.txt b/es2panda/test/compiler/ts/new_expression_116-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bc61a2875e20b97d068a26f369d57d515fa678a1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_116-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 21
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_116.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_116.ts b/es2panda/test/compiler/ts/new_expression_116.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bd5a5a580d72dd7681426f0886be08e0c1b2e7d8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_116.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: string) => any;
+var a = new foo(5,5);
diff --git a/es2panda/test/compiler/ts/new_expression_117-expected.txt b/es2panda/test/compiler/ts/new_expression_117-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c848839b0ba549c3133dee2995f38f1628d17c57
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_117-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_117.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_117.ts b/es2panda/test/compiler/ts/new_expression_117.ts
new file mode 100644
index 0000000000000000000000000000000000000000..40c7d2bb7e0396e792bafa0a33f16dbb68d84dba
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_117.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: string) => any;
+var a = new foo(5,false);
diff --git a/es2panda/test/compiler/ts/new_expression_118-expected.txt b/es2panda/test/compiler/ts/new_expression_118-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c415670be99e6c83a67c1d555eb45e8aa1b6d21c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_118-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_118.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_118.ts b/es2panda/test/compiler/ts/new_expression_118.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d2734341682caa1127a370388a3d04b9f6a8f2f2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_118.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: string) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_119-expected.txt b/es2panda/test/compiler/ts/new_expression_119-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b8701f2e2ae67bb9e4698a2af9fd8cf780bb0cd9
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_119-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_119.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_119.ts b/es2panda/test/compiler/ts/new_expression_119.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a951a83c90e108d7d8330e0a91574d27998b7b3d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_119.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: string) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_12-expected.txt b/es2panda/test/compiler/ts/new_expression_12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..362770a4ea693b4896ebaafe89a9f51f9fb8c146
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_12-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_12.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_12.ts b/es2panda/test/compiler/ts/new_expression_12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7e51fb2550f13972349a7fe8e31d549237e83d87
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_12.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: number): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_120-expected.txt b/es2panda/test/compiler/ts/new_expression_120-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d808912fcf628ef08e884b6bce39e5ac02268ac7
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_120-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_120.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_120.ts b/es2panda/test/compiler/ts/new_expression_120.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c85ff2ebe5e40f86aefe3dbe3d6932860a75d5e3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_120.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: string) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_121-expected.txt b/es2panda/test/compiler/ts/new_expression_121-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8062ac6a4ef93dc9b764c817d198138b4b9edc97
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_121-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [new_expression_121.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_121.ts b/es2panda/test/compiler/ts/new_expression_121.ts
new file mode 100644
index 0000000000000000000000000000000000000000..92a0e3701d327b8ced36af174229d437b926550b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_121.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: number) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_122-expected.txt b/es2panda/test/compiler/ts/new_expression_122-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d08b4975342cc94ccb257b9f88b4373705101b52
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_122-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_122.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_122.ts b/es2panda/test/compiler/ts/new_expression_122.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c6bbf6b09d650c1d689056a2f5bd17c88d69173d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_122.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: number) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_123-expected.txt b/es2panda/test/compiler/ts/new_expression_123-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..96ec8e6af16be78ca41fb9c0996be9397ebe0391
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_123-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [new_expression_123.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_123.ts b/es2panda/test/compiler/ts/new_expression_123.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9cca7f940d03f4d337bcfa7307071acd57d00bd3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_123.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: number) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_124-expected.txt b/es2panda/test/compiler/ts/new_expression_124-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6e2de247511af6d34ebf3456da4cb65d952b95b2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_124-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_124.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_124.ts b/es2panda/test/compiler/ts/new_expression_124.ts
new file mode 100644
index 0000000000000000000000000000000000000000..57ec1bd623b80984cf50e1bb5cc8274c4b3b0b53
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_124.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: number) => any;
+var a = new foo(5,false);
diff --git a/es2panda/test/compiler/ts/new_expression_125-expected.txt b/es2panda/test/compiler/ts/new_expression_125-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..86b4895edc75b3422e6bece3d34790af4edcc0d7
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_125-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_125.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_125.ts b/es2panda/test/compiler/ts/new_expression_125.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc1fbb258e6c8c5e24c4040b493fac3d035bc1dc
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_125.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: number) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_126-expected.txt b/es2panda/test/compiler/ts/new_expression_126-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9b6dd164d69ff2e1906d7a094232a0c485beb037
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_126-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_126.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_126.ts b/es2panda/test/compiler/ts/new_expression_126.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5658eb4642df81eff052c45400a8237aef303d94
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_126.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: number) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_127-expected.txt b/es2panda/test/compiler/ts/new_expression_127-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d87c396d88025d7bd83eee130c8504144f5171e3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_127-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_127.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_127.ts b/es2panda/test/compiler/ts/new_expression_127.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9d05d9134bdff13711e24970514031e999d3de37
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_127.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: number) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_128-expected.txt b/es2panda/test/compiler/ts/new_expression_128-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..56895db481778d0372cb012e3dc3e0fa7fba1915
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_128-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [new_expression_128.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_128.ts b/es2panda/test/compiler/ts/new_expression_128.ts
new file mode 100644
index 0000000000000000000000000000000000000000..498db42215159f812ef03c7efe79a71cff293a7c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_128.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: boolean) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_129-expected.txt b/es2panda/test/compiler/ts/new_expression_129-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8560062abeb9c3c576e432f8bd3821d788869756
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_129-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_129.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_129.ts b/es2panda/test/compiler/ts/new_expression_129.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8dfd23a23121eb8e1b85d7d1c8f0119347bbe62c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_129.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: boolean) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_13-expected.txt b/es2panda/test/compiler/ts/new_expression_13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d827b1631a24859bd944fbe8a4002bbeefd2e08
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_13-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_13.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_13.ts b/es2panda/test/compiler/ts/new_expression_13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7bf118924039410471558bf96dd2366ea276da30
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_13.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: number): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_130-expected.txt b/es2panda/test/compiler/ts/new_expression_130-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5717eff29fdbdbed22f76ee75a6dad44b2b8cd55
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_130-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'boolean'. [new_expression_130.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_130.ts b/es2panda/test/compiler/ts/new_expression_130.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c20224bab0ae9df3b4868f0c9d25b23a84c7cf9c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_130.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: boolean) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_131-expected.txt b/es2panda/test/compiler/ts/new_expression_131-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fedd4b0996a2da3cca03ec09420b9ccda8feb5f0
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_131-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 21
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_131.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_131.ts b/es2panda/test/compiler/ts/new_expression_131.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f10170f01b0b1199a4ee862930189daebd1e4d6d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_131.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: boolean) => any;
+var a = new foo(5,5);
diff --git a/es2panda/test/compiler/ts/new_expression_132-expected.txt b/es2panda/test/compiler/ts/new_expression_132-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4a98b9aae5b548a743c6b62d89c463ffc84038b8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_132-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_132.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_132.ts b/es2panda/test/compiler/ts/new_expression_132.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e5fb4c7f397592eb0cb58b4a115e24a791466f53
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_132.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: boolean) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_133-expected.txt b/es2panda/test/compiler/ts/new_expression_133-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4eb05a7c3ad1183cd1d49ce44f148e1c520ad88
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_133-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_133.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_133.ts b/es2panda/test/compiler/ts/new_expression_133.ts
new file mode 100644
index 0000000000000000000000000000000000000000..52aa5d25ee9dc26f8662b922b3a935b51025f72d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_133.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: boolean) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_134-expected.txt b/es2panda/test/compiler/ts/new_expression_134-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f5a525e6e346f9176201356539895bda1b2c3c01
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_134-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_134.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_134.ts b/es2panda/test/compiler/ts/new_expression_134.ts
new file mode 100644
index 0000000000000000000000000000000000000000..67f10484bbcea73df70b52f2056dcaf9c3d589b4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_134.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: number, b: boolean) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_135-expected.txt b/es2panda/test/compiler/ts/new_expression_135-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..246b250a7e216bdf9db1516b1a224c89d7bdd0ec
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_135-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'boolean'. [new_expression_135.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_135.ts b/es2panda/test/compiler/ts/new_expression_135.ts
new file mode 100644
index 0000000000000000000000000000000000000000..63e94e02abc6d7094a8ef36215455c10f08bfdb3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_135.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: string) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_136-expected.txt b/es2panda/test/compiler/ts/new_expression_136-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1d6bed2dde834e50419f74345b5b1b4ee4747e9d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_136-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_136.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_136.ts b/es2panda/test/compiler/ts/new_expression_136.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e4a9108db08e23fa153f88df178bc234a5e0dea2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_136.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: string) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_137-expected.txt b/es2panda/test/compiler/ts/new_expression_137-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b483fa27652052ab16d1bc801193bb81e3dd917f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_137-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_137.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_137.ts b/es2panda/test/compiler/ts/new_expression_137.ts
new file mode 100644
index 0000000000000000000000000000000000000000..41f30e9b50dcb397b3c181461b255902b58c565b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_137.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: string) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_138-expected.txt b/es2panda/test/compiler/ts/new_expression_138-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9f926e8b05f83b694a393f01e3eb786833af9458
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_138-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_138.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_138.ts b/es2panda/test/compiler/ts/new_expression_138.ts
new file mode 100644
index 0000000000000000000000000000000000000000..163be140b9ea88f7d38ffc723dd7d604b3eaa1f1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_138.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: string) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_139-expected.txt b/es2panda/test/compiler/ts/new_expression_139-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3fb4459a66b28a38128c9bcade976482cb67a2c5
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_139-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_139.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_139.ts b/es2panda/test/compiler/ts/new_expression_139.ts
new file mode 100644
index 0000000000000000000000000000000000000000..11308c39e5f4fff4e3d534e489e0143bc24c26ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_139.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: string) => any;
+var a = new foo(false,5);
diff --git a/es2panda/test/compiler/ts/new_expression_14-expected.txt b/es2panda/test/compiler/ts/new_expression_14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be361ea7b06530829069f050f5eb68b6904e1b16
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_14-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'bigint'. [new_expression_14.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_14.ts b/es2panda/test/compiler/ts/new_expression_14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f2c1286083f39e320e0a7f616e716b21617b558f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_14.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: bigint): any ;};
+var a = new foo("foo",5);
diff --git a/es2panda/test/compiler/ts/new_expression_140-expected.txt b/es2panda/test/compiler/ts/new_expression_140-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8f3ae2bc8cb0ca4bc158f2f2d70792fa44aaa3ae
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_140-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_140.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_140.ts b/es2panda/test/compiler/ts/new_expression_140.ts
new file mode 100644
index 0000000000000000000000000000000000000000..40cab27b39219562ba762975c2d156c450957b33
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_140.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: string) => any;
+var a = new foo(false,false);
diff --git a/es2panda/test/compiler/ts/new_expression_141-expected.txt b/es2panda/test/compiler/ts/new_expression_141-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e1afdaac85b6b7431ff7b2ac4310279699a03193
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_141-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_141.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_141.ts b/es2panda/test/compiler/ts/new_expression_141.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d8e190f866be1a14f415d18ae4eeafcf5e58bdf
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_141.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: string) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_142-expected.txt b/es2panda/test/compiler/ts/new_expression_142-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..27d0763817d4ef8e50abc970b241de4f9124718c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_142-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'boolean'. [new_expression_142.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_142.ts b/es2panda/test/compiler/ts/new_expression_142.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf3dc2410a83ed2c4fafae5b93ae1b349bf12b6a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_142.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: number) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_143-expected.txt b/es2panda/test/compiler/ts/new_expression_143-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8c75969814515d844681457d61a62c8017c7960d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_143-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_143.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_143.ts b/es2panda/test/compiler/ts/new_expression_143.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0a58cc16cf004ee92507c2bc643b4df511b77943
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_143.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: number) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_144-expected.txt b/es2panda/test/compiler/ts/new_expression_144-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e2992488870933e50b16cd25021b423c602ea068
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_144-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_144.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_144.ts b/es2panda/test/compiler/ts/new_expression_144.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4e5ee9de163ef51a01133064e716c3e98961ad92
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_144.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: number) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_145-expected.txt b/es2panda/test/compiler/ts/new_expression_145-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..783f2ac0841e14873475f471a59b643b97da656b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_145-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_145.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_145.ts b/es2panda/test/compiler/ts/new_expression_145.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0f2619e0726398ab3e83837f3b16340c5b8acfd7
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_145.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: number) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_146-expected.txt b/es2panda/test/compiler/ts/new_expression_146-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..08fb3e7e623b5d8b7acb66575cf9d02f33a00e08
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_146-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'number'. [new_expression_146.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_146.ts b/es2panda/test/compiler/ts/new_expression_146.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0b7f55ea5042b4abff6948760b66cbabc2fc54d5
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_146.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: number) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_147-expected.txt b/es2panda/test/compiler/ts/new_expression_147-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dea5cc4c6438a54060c32d779e13c2e3bbc09ef4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_147-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_147.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_147.ts b/es2panda/test/compiler/ts/new_expression_147.ts
new file mode 100644
index 0000000000000000000000000000000000000000..52e55ea6f531fe32cd7e7cd66273bac714f3a6c5
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_147.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: number) => any;
+var a = new foo(false,false);
diff --git a/es2panda/test/compiler/ts/new_expression_148-expected.txt b/es2panda/test/compiler/ts/new_expression_148-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..acbd9d44fe542ac381628f4f0cdd762efbfe9e72
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_148-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_148.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_148.ts b/es2panda/test/compiler/ts/new_expression_148.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aaa14eedfa5e2996bb446a0588f847e3bec80c61
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_148.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: number) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_149-expected.txt b/es2panda/test/compiler/ts/new_expression_149-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c0c9e4d0a6a2c977fc82ca12be918045f33d736e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_149-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'boolean'. [new_expression_149.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_149.ts b/es2panda/test/compiler/ts/new_expression_149.ts
new file mode 100644
index 0000000000000000000000000000000000000000..63d7819a1d0938af4240733afc1d1ac2f0327a8e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_149.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: boolean) => any;
+var a = new foo("foo","foo");
diff --git a/es2panda/test/compiler/ts/new_expression_15-expected.txt b/es2panda/test/compiler/ts/new_expression_15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..79ab41a420a9bc20d9794e185e7826f2897c0dd4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_15-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'bigint'. [new_expression_15.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_15.ts b/es2panda/test/compiler/ts/new_expression_15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..78386e13bffffbf3452a08cd47d6e5d1a2fa37a1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_15.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: bigint): any ;};
+var a = new foo("foo",false);
diff --git a/es2panda/test/compiler/ts/new_expression_150-expected.txt b/es2panda/test/compiler/ts/new_expression_150-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..890fa69c9266d8fe47a7644c23153fcba79263ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_150-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_150.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_150.ts b/es2panda/test/compiler/ts/new_expression_150.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3b1c88dc7869fa4ccac49279bdf267b9b9bc2f90
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_150.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: boolean) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_151-expected.txt b/es2panda/test/compiler/ts/new_expression_151-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d949e8be50c7f3b4ff2c35e213faa7a3659f4fbc
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_151-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_151.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_151.ts b/es2panda/test/compiler/ts/new_expression_151.ts
new file mode 100644
index 0000000000000000000000000000000000000000..41ca4fe28c579281793b8754a7d43461f425a128
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_151.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: boolean) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_152-expected.txt b/es2panda/test/compiler/ts/new_expression_152-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..127b1ceb56bd2231103aebbf992198259822ef14
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_152-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_152.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_152.ts b/es2panda/test/compiler/ts/new_expression_152.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e346cebe659a28e4a31e3b1964cb1868806b792
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_152.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: boolean) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_153-expected.txt b/es2panda/test/compiler/ts/new_expression_153-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..529906dd8eed781e114dc1d6059b766beafbcd5a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_153-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'string' is not assignable to parameter of type 'boolean'. [new_expression_153.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_153.ts b/es2panda/test/compiler/ts/new_expression_153.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4af5eccdab0f82dffa44f46a3f98f06731f9fc44
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_153.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: boolean) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_154-expected.txt b/es2panda/test/compiler/ts/new_expression_154-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3560f000f1a9e6fc2ab5330f45b40f431e5d943
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_154-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_154.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_154.ts b/es2panda/test/compiler/ts/new_expression_154.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e68086a8f36a2d457ed2af7ecdef6001f8021544
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_154.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: boolean) => any;
+var a = new foo(false,5);
diff --git a/es2panda/test/compiler/ts/new_expression_155-expected.txt b/es2panda/test/compiler/ts/new_expression_155-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4ffd75545c40e90ab5d0611d559a562c483ffc5
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_155-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_155.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_155.ts b/es2panda/test/compiler/ts/new_expression_155.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eb40d3b5c86c13f3fa920d9ddcfaaaceb140348d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_155.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: boolean, b: boolean) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_156-expected.txt b/es2panda/test/compiler/ts/new_expression_156-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..99db8e987ab76b404a4ab892a41ea9316adaf7d6
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_156-expected.txt
@@ -0,0 +1,218 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 37
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 0. [new_expression_156.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_156.ts b/es2panda/test/compiler/ts/new_expression_156.ts
new file mode 100644
index 0000000000000000000000000000000000000000..55c1fbb14c3451dda8bbad2610a866dcdd5f2092
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_156.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: any, b: any) => any;
+var a = new foo();
diff --git a/es2panda/test/compiler/ts/new_expression_157-expected.txt b/es2panda/test/compiler/ts/new_expression_157-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21af4f331070f2e742753178db4e24c7b3e73ef0
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_157-expected.txt
@@ -0,0 +1,261 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 37
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 30
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 31
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 32
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 3. [new_expression_157.ts:2:25]
diff --git a/es2panda/test/compiler/ts/new_expression_157.ts b/es2panda/test/compiler/ts/new_expression_157.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c1fb42d57762855576a79b53b219623bc3b39cd3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_157.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: any, b: any) => any;
+var a = new foo("foo",5,false);
diff --git a/es2panda/test/compiler/ts/new_expression_158-expected.txt b/es2panda/test/compiler/ts/new_expression_158-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6090905669c71cd56ba547be1a9e87cd97c1fd7c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_158-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [],
+              "returnType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'string'. [new_expression_158.ts:3:1]
diff --git a/es2panda/test/compiler/ts/new_expression_158.ts b/es2panda/test/compiler/ts/new_expression_158.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9443d5ef010cedf15574417f8517b1d26eeef06f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_158.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new () => string;
+var a = new foo();
+a = 5;
diff --git a/es2panda/test/compiler/ts/new_expression_159-expected.txt b/es2panda/test/compiler/ts/new_expression_159-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dc5232c31e81189f480e478112c147c148f1604d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_159-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [],
+              "returnType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'false' is not assignable to type 'string'. [new_expression_159.ts:3:1]
diff --git a/es2panda/test/compiler/ts/new_expression_159.ts b/es2panda/test/compiler/ts/new_expression_159.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b9b4d92e14237b195823b66879e88ed653ad4f8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_159.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new () => string;
+var a = new foo();
+a = false;
diff --git a/es2panda/test/compiler/ts/new_expression_16-expected.txt b/es2panda/test/compiler/ts/new_expression_16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..576e6f79955f3b94a67953304132ab894b789423
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_16-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_16.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_16.ts b/es2panda/test/compiler/ts/new_expression_16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0f1f703ccbc435217cc3a0f6d4a36bd1b1d72dcf
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_16.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: bigint): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_160-expected.txt b/es2panda/test/compiler/ts/new_expression_160-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..24d1d50b5a3096c0b98c75c763ff8f39b7801640
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_160-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'number'. [new_expression_160.ts:3:1]
diff --git a/es2panda/test/compiler/ts/new_expression_160.ts b/es2panda/test/compiler/ts/new_expression_160.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d5b9e8aadfa039a2f3a6d1b68d4369671a18e836
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_160.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new () => number;
+var a = new foo();
+a = "foo";
diff --git a/es2panda/test/compiler/ts/new_expression_161-expected.txt b/es2panda/test/compiler/ts/new_expression_161-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..42399bed1557a3c73ab433ea8ad0b52757f0ff39
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_161-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'false' is not assignable to type 'number'. [new_expression_161.ts:3:1]
diff --git a/es2panda/test/compiler/ts/new_expression_161.ts b/es2panda/test/compiler/ts/new_expression_161.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5df918f2ebdcad07d7ad929abb8e6796af2f12dc
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_161.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new () => number;
+var a = new foo();
+a = false;
diff --git a/es2panda/test/compiler/ts/new_expression_162-expected.txt b/es2panda/test/compiler/ts/new_expression_162-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..77049b95535c980023ba90acca18a0a104146290
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_162-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [],
+              "returnType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '"foo"' is not assignable to type 'boolean'. [new_expression_162.ts:3:1]
diff --git a/es2panda/test/compiler/ts/new_expression_162.ts b/es2panda/test/compiler/ts/new_expression_162.ts
new file mode 100644
index 0000000000000000000000000000000000000000..15aa0c70b3bfac7dd0aca9f38f693543cf03a0ac
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_162.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new () => boolean;
+var a = new foo();
+a = "foo";
diff --git a/es2panda/test/compiler/ts/new_expression_163-expected.txt b/es2panda/test/compiler/ts/new_expression_163-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bf5d2e2428a4d9e0ed48595031afbcbc47d6021b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_163-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [],
+              "returnType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type '5' is not assignable to type 'boolean'. [new_expression_163.ts:3:1]
diff --git a/es2panda/test/compiler/ts/new_expression_163.ts b/es2panda/test/compiler/ts/new_expression_163.ts
new file mode 100644
index 0000000000000000000000000000000000000000..80631646e2facd7e0bf93e0483619fc473c6ba23
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_163.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new () => boolean;
+var a = new foo();
+a = 5;
diff --git a/es2panda/test/compiler/ts/new_expression_17-expected.txt b/es2panda/test/compiler/ts/new_expression_17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ed35bd99ab53f0288677bf2fe060861e00e3c632
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_17-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_17.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_17.ts b/es2panda/test/compiler/ts/new_expression_17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a652201337381934ce0622c6f83772735ee041fa
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_17.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: bigint): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_18-expected.txt b/es2panda/test/compiler/ts/new_expression_18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..149048760ab5bb6aa1c9435a615e7e5c9f16f4c3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_18-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_18.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_18.ts b/es2panda/test/compiler/ts/new_expression_18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..be112eaa4eb7d46c78206a5941a9237f219b2de4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_18.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: bigint): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_19-expected.txt b/es2panda/test/compiler/ts/new_expression_19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..764651340c092d8085eb6fc178fe3096203f4bab
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_19-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_19.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_19.ts b/es2panda/test/compiler/ts/new_expression_19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e64eb1aff1f24e29df64361de0059e82a88fe01a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_19.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: bigint): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_2-expected.txt b/es2panda/test/compiler/ts/new_expression_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b3b7987cc1329eaf5b2393f0f2f24b9d9cd7a25c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_2-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_2.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_2.ts b/es2panda/test/compiler/ts/new_expression_2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4c7089af576713d9aa9c2837a5f9a1455c138604
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_2.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: string): any ;};
+var a = new foo("foo",false);
diff --git a/es2panda/test/compiler/ts/new_expression_20-expected.txt b/es2panda/test/compiler/ts/new_expression_20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..20750312227503090f38532f06342c6cd3f4fc42
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_20-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_20.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_20.ts b/es2panda/test/compiler/ts/new_expression_20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0b2eaac8c0f6c3b3d4e9fc6c8e23d02613f3952c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_20.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: bigint): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_21-expected.txt b/es2panda/test/compiler/ts/new_expression_21-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b40613adc53dba551e1619a715f2eeb8d5a26a5f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_21-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_21.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_21.ts b/es2panda/test/compiler/ts/new_expression_21.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bfa09f47f83a6cc37e711faee0ec84f6b8b2265c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_21.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: boolean): any ;};
+var a = new foo("foo",5);
diff --git a/es2panda/test/compiler/ts/new_expression_22-expected.txt b/es2panda/test/compiler/ts/new_expression_22-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5fc2ed79981993190b1bd76d3a706180f33664f4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_22-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_22.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_22.ts b/es2panda/test/compiler/ts/new_expression_22.ts
new file mode 100644
index 0000000000000000000000000000000000000000..35c7e370de4e721cb8e6270d244995137851966e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_22.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: boolean): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_23-expected.txt b/es2panda/test/compiler/ts/new_expression_23-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..35fadeedf6979ceb81e3ea3d8b13c88d9b9f8932
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_23-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_23.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_23.ts b/es2panda/test/compiler/ts/new_expression_23.ts
new file mode 100644
index 0000000000000000000000000000000000000000..82abb42d4336630eb3f112ebd5647c8b997bf150
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_23.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: boolean): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_24-expected.txt b/es2panda/test/compiler/ts/new_expression_24-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..49b0add9220d4ce4acb3912ddea65f4d0b25d303
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_24-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_24.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_24.ts b/es2panda/test/compiler/ts/new_expression_24.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b755e242841515474c61c8af948968d27f264a6
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_24.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: boolean): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_25-expected.txt b/es2panda/test/compiler/ts/new_expression_25-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c696880d8651797213209ca1ef079924a6be362
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_25-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_25.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_25.ts b/es2panda/test/compiler/ts/new_expression_25.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9bd97e9a967da556ab8cf9019058e3c0337659a8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_25.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: boolean): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_26-expected.txt b/es2panda/test/compiler/ts/new_expression_26-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1d3ebd0821a47bae8e9db1a922bfc56801a16b02
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_26-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_26.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_26.ts b/es2panda/test/compiler/ts/new_expression_26.ts
new file mode 100644
index 0000000000000000000000000000000000000000..af0fdd1d909b09b641a8a621d2a0706023a62e56
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_26.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: boolean): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_27-expected.txt b/es2panda/test/compiler/ts/new_expression_27-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c9420960a507c02118191533a461ce42415e883e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_27-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_27.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_27.ts b/es2panda/test/compiler/ts/new_expression_27.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b4632d770a7a5cd1859c7d33352f0a85f4243049
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_27.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: string): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_28-expected.txt b/es2panda/test/compiler/ts/new_expression_28-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d48762d2a336ffbddc4577824794f8dae67fb98b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_28-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 21
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_28.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_28.ts b/es2panda/test/compiler/ts/new_expression_28.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e632eeed4c8fde1e1a7e836ad363dd1c650ea4b1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_28.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: string): any ;};
+var a = new foo(5,5);
diff --git a/es2panda/test/compiler/ts/new_expression_29-expected.txt b/es2panda/test/compiler/ts/new_expression_29-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f015a5c3044e3c5a08ad4392d42dcc53da506766
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_29-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_29.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_29.ts b/es2panda/test/compiler/ts/new_expression_29.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e34d1dd8868c59416046c7c484ecacb14281b4a1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_29.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: string): any ;};
+var a = new foo(5,false);
diff --git a/es2panda/test/compiler/ts/new_expression_3-expected.txt b/es2panda/test/compiler/ts/new_expression_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..290660c39afa5911046b4cc7a76ce1ab0ff145ee
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_3-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_3.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_3.ts b/es2panda/test/compiler/ts/new_expression_3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c6e065b1e506d25f94cf87ed4b9a871580a31eeb
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_3.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: string): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_30-expected.txt b/es2panda/test/compiler/ts/new_expression_30-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d1b19ff5d1d4651d047efa5ed6c36d9121f265dd
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_30-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_30.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_30.ts b/es2panda/test/compiler/ts/new_expression_30.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6653101eaddf5c8dd36371f2fe2660b5a116ec2f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_30.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: string): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_31-expected.txt b/es2panda/test/compiler/ts/new_expression_31-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5f5d2cf94afc25cc88031ddd6194d4242bef1c14
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_31-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_31.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_31.ts b/es2panda/test/compiler/ts/new_expression_31.ts
new file mode 100644
index 0000000000000000000000000000000000000000..920f3d39bb08be3ad5bded2f41b2dcd84b2693f4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_31.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: string): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_32-expected.txt b/es2panda/test/compiler/ts/new_expression_32-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2bc9ce9e5668bcf364230df31c5d5cf5e79a67a7
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_32-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_32.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_32.ts b/es2panda/test/compiler/ts/new_expression_32.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b1c7f2a4316a8b54153a51b339b3c362e30a5ada
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_32.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: string): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_33-expected.txt b/es2panda/test/compiler/ts/new_expression_33-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..63deff832c965d2362386100b08ae11dd020ac8d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_33-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_33.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_33.ts b/es2panda/test/compiler/ts/new_expression_33.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6fe0ad6fefe985916c551ab319ed9b6334139d22
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_33.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: number): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_34-expected.txt b/es2panda/test/compiler/ts/new_expression_34-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..49a5de267c291d43dc3772f8e5d0139052aeabfa
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_34-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_34.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_34.ts b/es2panda/test/compiler/ts/new_expression_34.ts
new file mode 100644
index 0000000000000000000000000000000000000000..080362108d7ff016ae16cf896e3aa5d0d9567883
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_34.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: number): any ;};
+var a = new foo(5,false);
diff --git a/es2panda/test/compiler/ts/new_expression_35-expected.txt b/es2panda/test/compiler/ts/new_expression_35-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..08411135450d13b40597022db00469a30958ebcd
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_35-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_35.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_35.ts b/es2panda/test/compiler/ts/new_expression_35.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a9a7b5e5504a1e2fd6ab37e55e607af56f60d782
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_35.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: number): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_36-expected.txt b/es2panda/test/compiler/ts/new_expression_36-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..783c8366e2eb86fd3d30cd42a1b78d03589238e7
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_36-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_36.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_36.ts b/es2panda/test/compiler/ts/new_expression_36.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f1913aac64da9b83045a5d70016d05571e62033e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_36.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: number): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_37-expected.txt b/es2panda/test/compiler/ts/new_expression_37-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..07827ac7c81463d31170d809294d1025062e807e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_37-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_37.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_37.ts b/es2panda/test/compiler/ts/new_expression_37.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb32d0b9681011683d7804bdb408326ce5ff0e6f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_37.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: number): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_38-expected.txt b/es2panda/test/compiler/ts/new_expression_38-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e2bf22f05c216aebe0d18bf77937f4ab3f33fb3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_38-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_38.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_38.ts b/es2panda/test/compiler/ts/new_expression_38.ts
new file mode 100644
index 0000000000000000000000000000000000000000..69b8e7f22e8fe236b3861055844bc51fd95d80ad
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_38.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: bigint): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_39-expected.txt b/es2panda/test/compiler/ts/new_expression_39-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dc26cdf96c739c71c1f75085cf4f0542d034b1d4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_39-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 21
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'bigint'. [new_expression_39.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_39.ts b/es2panda/test/compiler/ts/new_expression_39.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f628ad62be3a6d0b53542734e5e2b0bc090d6569
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_39.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: bigint): any ;};
+var a = new foo(5,5);
diff --git a/es2panda/test/compiler/ts/new_expression_4-expected.txt b/es2panda/test/compiler/ts/new_expression_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41a4e4f66baca71546ef5800ef8d9c2225508aae
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_4-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_4.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_4.ts b/es2panda/test/compiler/ts/new_expression_4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88163f265ebd9b8db5b6420a5b87d881b256c9b3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_4.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: string): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_40-expected.txt b/es2panda/test/compiler/ts/new_expression_40-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..452fa112df563afef0bc125266adfe480dfb80fe
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_40-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'bigint'. [new_expression_40.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_40.ts b/es2panda/test/compiler/ts/new_expression_40.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c2b123c3d616f6b725b075f63a0b3fd00a365455
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_40.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: bigint): any ;};
+var a = new foo(5,false);
diff --git a/es2panda/test/compiler/ts/new_expression_41-expected.txt b/es2panda/test/compiler/ts/new_expression_41-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be999a421b34a23155065bb51b0492e319c5d453
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_41-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_41.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_41.ts b/es2panda/test/compiler/ts/new_expression_41.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c97ac517f72e0a554b3f01f8d51e3723da8978d6
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_41.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: bigint): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_42-expected.txt b/es2panda/test/compiler/ts/new_expression_42-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e2f8bf6d26b709fc09f084279bbb3b855a3f5359
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_42-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_42.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_42.ts b/es2panda/test/compiler/ts/new_expression_42.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d92717d2f0c36496c052123593af5b12117ef32d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_42.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: bigint): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_43-expected.txt b/es2panda/test/compiler/ts/new_expression_43-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..37117403cdf847b2c92fa433ead380d6ad0bb244
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_43-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_43.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_43.ts b/es2panda/test/compiler/ts/new_expression_43.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ff04cbcfe95cb19c081a7a28e3d3c9c2b0d27fed
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_43.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: bigint): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_44-expected.txt b/es2panda/test/compiler/ts/new_expression_44-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eba0d7509bedb38b952d495dc88699e145797cfe
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_44-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_44.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_44.ts b/es2panda/test/compiler/ts/new_expression_44.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8cffd30c4d51a372466bbfedfe27f1a55e9f3bce
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_44.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: boolean): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_45-expected.txt b/es2panda/test/compiler/ts/new_expression_45-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d2ec5ca43d922697d6bd10a04a2f61f2cfaf9440
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_45-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 21
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_45.ts:2:19]
diff --git a/es2panda/test/compiler/ts/new_expression_45.ts b/es2panda/test/compiler/ts/new_expression_45.ts
new file mode 100644
index 0000000000000000000000000000000000000000..92ca38a2fe05c5c71010effea7c288d9189a2e59
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_45.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: boolean): any ;};
+var a = new foo(5,5);
diff --git a/es2panda/test/compiler/ts/new_expression_46-expected.txt b/es2panda/test/compiler/ts/new_expression_46-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..23100abf73da845ccb254be830a82222289c1d68
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_46-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_46.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_46.ts b/es2panda/test/compiler/ts/new_expression_46.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1ac3a63e6394af23b53e6a282d4c9218c18a3acc
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_46.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: boolean): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_47-expected.txt b/es2panda/test/compiler/ts/new_expression_47-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..97fc19a3ed27805ac6d9a2887b6d78717c1d0c56
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_47-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_47.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_47.ts b/es2panda/test/compiler/ts/new_expression_47.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d3cc683eb49ea37592eb51bf23b7408ca8cc8045
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_47.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: boolean): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_48-expected.txt b/es2panda/test/compiler/ts/new_expression_48-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41b8bd4f508b4e5a26efde8d632bfb4dc5409eeb
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_48-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_48.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_48.ts b/es2panda/test/compiler/ts/new_expression_48.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0a43aec929c4ba3250757050df006e951fbbaf91
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_48.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: number, b: boolean): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_49-expected.txt b/es2panda/test/compiler/ts/new_expression_49-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ae3897321539d1a0b287367ba199a797629f93d2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_49-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_49.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_49.ts b/es2panda/test/compiler/ts/new_expression_49.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9116b15f8abec03b64564085426c5249118cca47
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_49.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: string): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_5-expected.txt b/es2panda/test/compiler/ts/new_expression_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f72a5e176d7857fcb64bacbcb402726feb5b13df
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_5-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_5.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_5.ts b/es2panda/test/compiler/ts/new_expression_5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bb69d08705fc755f571d7f4bc7c448f3b9d5a8e3
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_5.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: string): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_50-expected.txt b/es2panda/test/compiler/ts/new_expression_50-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..54a6e474acba088f9107f654e7fe385af26d08c5
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_50-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'bigint'. [new_expression_50.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_50.ts b/es2panda/test/compiler/ts/new_expression_50.ts
new file mode 100644
index 0000000000000000000000000000000000000000..821e4efaf4c414a10d623b3cf0767c617661254d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_50.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: string): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_51-expected.txt b/es2panda/test/compiler/ts/new_expression_51-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..601425d556871377283c00a6017d44c5debc2f5b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_51-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_51.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_51.ts b/es2panda/test/compiler/ts/new_expression_51.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1bab477598104704e190c5cf83d0661d653c0627
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_51.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: string): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_52-expected.txt b/es2panda/test/compiler/ts/new_expression_52-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..28719d33b290b751b9d8e13aab4ba218331393eb
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_52-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'bigint'. [new_expression_52.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_52.ts b/es2panda/test/compiler/ts/new_expression_52.ts
new file mode 100644
index 0000000000000000000000000000000000000000..21324da4fed4cc281b6cb1e86d5c75d32fd309b6
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_52.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: string): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_53-expected.txt b/es2panda/test/compiler/ts/new_expression_53-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e17dc9b3a38d60e06b01d92465cbba78b08b1ca2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_53-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_53.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_53.ts b/es2panda/test/compiler/ts/new_expression_53.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5c907d0fd4686f4190494515fb0f5a0bcc1279da
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_53.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: string): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_54-expected.txt b/es2panda/test/compiler/ts/new_expression_54-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dde915b1430eceaae04be386464928420a49155f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_54-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_54.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_54.ts b/es2panda/test/compiler/ts/new_expression_54.ts
new file mode 100644
index 0000000000000000000000000000000000000000..44519a34eab63712bdbde38f53fcf4e1e2564c09
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_54.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: number): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_55-expected.txt b/es2panda/test/compiler/ts/new_expression_55-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c35483458eaa3822f59e65762f7cc25620d796ab
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_55-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'bigint'. [new_expression_55.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_55.ts b/es2panda/test/compiler/ts/new_expression_55.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ec4547e0b4dfe723ff5a60d9eb7877b5708d1816
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_55.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: number): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_56-expected.txt b/es2panda/test/compiler/ts/new_expression_56-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e27f30d89945840c868261848472a2053d296a98
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_56-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_56.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_56.ts b/es2panda/test/compiler/ts/new_expression_56.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b99ddffa843f76a1ffb67af6bafd194cd5e791cd
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_56.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: number): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_57-expected.txt b/es2panda/test/compiler/ts/new_expression_57-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7790fec6db13c67073f844f8f5508eb6608a8db4
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_57-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'bigint'. [new_expression_57.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_57.ts b/es2panda/test/compiler/ts/new_expression_57.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1e60125cbfb67661e95b49b1a2255185cec55615
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_57.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: number): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_58-expected.txt b/es2panda/test/compiler/ts/new_expression_58-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ba5fd8b5894c916503222350b2c81e4cf38a1d2c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_58-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_58.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_58.ts b/es2panda/test/compiler/ts/new_expression_58.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7e99e32dcbe832fc183a57475dab4f28e45c2d5f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_58.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: number): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_59-expected.txt b/es2panda/test/compiler/ts/new_expression_59-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..39a76c66aa391537096c594c90e2090875bb86ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_59-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_59.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_59.ts b/es2panda/test/compiler/ts/new_expression_59.ts
new file mode 100644
index 0000000000000000000000000000000000000000..334ed660e76350cb2cc972aed5febed2a4f60ec7
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_59.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: bigint): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_6-expected.txt b/es2panda/test/compiler/ts/new_expression_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..623d6eb9f3c97239a6d6a65bf78f70c65c68c939
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_6-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_6.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_6.ts b/es2panda/test/compiler/ts/new_expression_6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f3b715d92e7fc49bb8f5ff882f3ecbe829b20c81
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: string): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_60-expected.txt b/es2panda/test/compiler/ts/new_expression_60-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..46ed617c9c36990ac09134db677bd09498e6748f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_60-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'bigint'. [new_expression_60.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_60.ts b/es2panda/test/compiler/ts/new_expression_60.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6875b153a6c147d54807965d5e2679603f234a74
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_60.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: bigint): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_61-expected.txt b/es2panda/test/compiler/ts/new_expression_61-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8673880a548da7be1582212140f3aa0709b8a066
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_61-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_61.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_61.ts b/es2panda/test/compiler/ts/new_expression_61.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6a35c94ff1886b0e92cfc1a57c4cfb44d9e90f95
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_61.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: bigint): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_62-expected.txt b/es2panda/test/compiler/ts/new_expression_62-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f3a9a3c3b14b0408a9bdf5d1c8588f7717cefd16
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_62-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'bigint'. [new_expression_62.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_62.ts b/es2panda/test/compiler/ts/new_expression_62.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9745650c53de7e1d27e79ee338882c605d8ab0c1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_62.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: bigint): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_63-expected.txt b/es2panda/test/compiler/ts/new_expression_63-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..caf9d86176c0955c7fa01e2c98cab1f0d075a272
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_63-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_63.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_63.ts b/es2panda/test/compiler/ts/new_expression_63.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e2783de8755fc6d0f9797c83175e06174df1821e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_63.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: bigint): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_64-expected.txt b/es2panda/test/compiler/ts/new_expression_64-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f9842baa2719c514d7177348cab510409d65fcd0
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_64-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_64.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_64.ts b/es2panda/test/compiler/ts/new_expression_64.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae4c9eb06a862b42a8d2bf4d3ad47527ae83e417
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_64.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: boolean): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_65-expected.txt b/es2panda/test/compiler/ts/new_expression_65-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0d9ca47b6548e01df6410469b63630e13e9e01f0
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_65-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'bigint'. [new_expression_65.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_65.ts b/es2panda/test/compiler/ts/new_expression_65.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f75565e785df73463275580dbb27ee30550a7399
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_65.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: boolean): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_66-expected.txt b/es2panda/test/compiler/ts/new_expression_66-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0b5108c9482a726261b3709d98f2227218548945
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_66-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_66.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_66.ts b/es2panda/test/compiler/ts/new_expression_66.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf23557fb0873e84b269ff84435a830a3c13ccd1
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_66.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: boolean): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_67-expected.txt b/es2panda/test/compiler/ts/new_expression_67-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3529d988a947e3a99f575f36f41ef67cf3f32df8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_67-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'bigint'. [new_expression_67.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_67.ts b/es2panda/test/compiler/ts/new_expression_67.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f5e95ce763e181d9f4a06f0d85da612930865c31
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_67.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: boolean): any ;};
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_68-expected.txt b/es2panda/test/compiler/ts/new_expression_68-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..63f828ef2e2134be7559bc278c29a08bc0226f4f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_68-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_68.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_68.ts b/es2panda/test/compiler/ts/new_expression_68.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0c7e85c727b6c1abb16c19969106be73fdae87a5
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_68.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: bigint, b: boolean): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_69-expected.txt b/es2panda/test/compiler/ts/new_expression_69-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c6b13a3a9a3196c0ed5487ee101fbca790d72183
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_69-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_69.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_69.ts b/es2panda/test/compiler/ts/new_expression_69.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4a8c4e80d437a6c73dd6909d990d82fbecbd72a8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_69.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: string): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_7-expected.txt b/es2panda/test/compiler/ts/new_expression_7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..37bc7a7fc2b9be61e0238991992729b99a472c0b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_7-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_7.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_7.ts b/es2panda/test/compiler/ts/new_expression_7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7a3de4cf90eaaebda19f121ac2208bcb0ce10272
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_7.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: string): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_70-expected.txt b/es2panda/test/compiler/ts/new_expression_70-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9103bb862aa0040adacbe614c3807729e25e00fe
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_70-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_70.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_70.ts b/es2panda/test/compiler/ts/new_expression_70.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1a519103640ff2229c3b1d9b9b64834415733a38
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_70.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: string): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_71-expected.txt b/es2panda/test/compiler/ts/new_expression_71-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a8af6ef51ba045d654c404f73b614fd6c040c40b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_71-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_71.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_71.ts b/es2panda/test/compiler/ts/new_expression_71.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0994e895877ce6bfb5620571a2ab0d6ed23c760
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_71.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: string): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_72-expected.txt b/es2panda/test/compiler/ts/new_expression_72-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3b436e9c83a57bc31df57a2c9c3ebf26a4bdade8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_72-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_72.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_72.ts b/es2panda/test/compiler/ts/new_expression_72.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1aadea40cce315ba0e7539c9d2ec6eae654b3c14
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_72.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: string): any ;};
+var a = new foo(false,5);
diff --git a/es2panda/test/compiler/ts/new_expression_73-expected.txt b/es2panda/test/compiler/ts/new_expression_73-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..30afbceea7d804a7121871981dbb53439a9f020b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_73-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_73.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_73.ts b/es2panda/test/compiler/ts/new_expression_73.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b46fef8fc161c3b8ed12075e5006d37c67403fec
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_73.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: string): any ;};
+var a = new foo(false,false);
diff --git a/es2panda/test/compiler/ts/new_expression_74-expected.txt b/es2panda/test/compiler/ts/new_expression_74-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..810fdfa6ac1860cff3dcecc4b5d06fe447b66080
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_74-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_74.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_74.ts b/es2panda/test/compiler/ts/new_expression_74.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6dbd9fea030e78117369ee2166a324cccf579442
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_74.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: string): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_75-expected.txt b/es2panda/test/compiler/ts/new_expression_75-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d160a8bf1809b03e32eba3b28e86a01c8e7e191
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_75-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_75.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_75.ts b/es2panda/test/compiler/ts/new_expression_75.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bccfe894c8202c519eadb36b0e67e081dd9b62ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_75.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: number): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_76-expected.txt b/es2panda/test/compiler/ts/new_expression_76-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5400961db78dc7cf131f91c21f2ae50685030f3d
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_76-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_76.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_76.ts b/es2panda/test/compiler/ts/new_expression_76.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8f700d098f34bde0aa00d0a51d6386e9e403658f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_76.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: number): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_77-expected.txt b/es2panda/test/compiler/ts/new_expression_77-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..386dc8c6cfe90f633be3521d8c85929bf08b7e88
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_77-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_77.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_77.ts b/es2panda/test/compiler/ts/new_expression_77.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e547c05255908a445aa57bf127c6d7f1aac08b27
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_77.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: number): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_78-expected.txt b/es2panda/test/compiler/ts/new_expression_78-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..38761edc10734ef627e7078536a551640153831c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_78-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_78.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_78.ts b/es2panda/test/compiler/ts/new_expression_78.ts
new file mode 100644
index 0000000000000000000000000000000000000000..66bf311264518c01e137e5ba7201c3e72cb1aab8
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_78.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: number): any ;};
+var a = new foo(false,false);
diff --git a/es2panda/test/compiler/ts/new_expression_79-expected.txt b/es2panda/test/compiler/ts/new_expression_79-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2ce09ac69e2fdc4ce9201e9ae23a4ccd338f5c4e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_79-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_79.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_79.ts b/es2panda/test/compiler/ts/new_expression_79.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c2740f4cc4723fa3db51034a912cc8a0303c6010
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_79.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: number): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_8-expected.txt b/es2panda/test/compiler/ts/new_expression_8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c2154ee9880b8b51b5ed86ead09a5f15f8a1a71b
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_8-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'number'. [new_expression_8.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_8.ts b/es2panda/test/compiler/ts/new_expression_8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fc0a5ffbeb0725a7dd7d70b44cf093948e9a234c
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_8.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: number): any ;};
+var a = new foo("foo",false);
diff --git a/es2panda/test/compiler/ts/new_expression_80-expected.txt b/es2panda/test/compiler/ts/new_expression_80-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..06a90efb7f1ecebcc9aef403a850ff47ccf961ec
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_80-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_80.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_80.ts b/es2panda/test/compiler/ts/new_expression_80.ts
new file mode 100644
index 0000000000000000000000000000000000000000..080c8076efea7cb02703785847f2decdbb339260
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_80.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: bigint): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_81-expected.txt b/es2panda/test/compiler/ts/new_expression_81-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9af1d606f4387c3a96ebd266bb740c6a28553b9a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_81-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_81.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_81.ts b/es2panda/test/compiler/ts/new_expression_81.ts
new file mode 100644
index 0000000000000000000000000000000000000000..64356b5e0cd1261f7ee0e7dc01761feffd0ccb94
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_81.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: bigint): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_82-expected.txt b/es2panda/test/compiler/ts/new_expression_82-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..36327aa1e0c8a6b8e1fc17e0e903d5e7de83aa9a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_82-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_82.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_82.ts b/es2panda/test/compiler/ts/new_expression_82.ts
new file mode 100644
index 0000000000000000000000000000000000000000..83b95c3b8d4690831e3486ce9d82ec8e33859e5f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_82.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: bigint): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_83-expected.txt b/es2panda/test/compiler/ts/new_expression_83-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4e47f72015c8a6a941af80bcf9edcada9b104d9f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_83-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'bigint'. [new_expression_83.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_83.ts b/es2panda/test/compiler/ts/new_expression_83.ts
new file mode 100644
index 0000000000000000000000000000000000000000..527ab530ca2ac62f0b03e94477c2bc5b818ccbb2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_83.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: bigint): any ;};
+var a = new foo(false,5);
diff --git a/es2panda/test/compiler/ts/new_expression_84-expected.txt b/es2panda/test/compiler/ts/new_expression_84-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5842545cd53012ae146ce8f7a78cb2a592328115
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_84-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'bigint'. [new_expression_84.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_84.ts b/es2panda/test/compiler/ts/new_expression_84.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f477c7a10ce924b69cf5639a406a5c8a21a5b54a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_84.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: bigint): any ;};
+var a = new foo(false,false);
diff --git a/es2panda/test/compiler/ts/new_expression_85-expected.txt b/es2panda/test/compiler/ts/new_expression_85-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bd4caa1e87184961c845ba1ee47d598271f0952e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_85-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBigIntKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_85.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_85.ts b/es2panda/test/compiler/ts/new_expression_85.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b3868de88ab03cec6587833fec33bb1a7e30cd80
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_85.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: bigint): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_86-expected.txt b/es2panda/test/compiler/ts/new_expression_86-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7084c101ff0d8e170b4f9bf7672c8f12036d95ba
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_86-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 47
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 48
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_86.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_86.ts b/es2panda/test/compiler/ts/new_expression_86.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0ccc9a1dac1519ea5b549d16031ac563372ff1ac
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_86.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: boolean): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_87-expected.txt b/es2panda/test/compiler/ts/new_expression_87-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..18a50747b49ee922ca28a3507566e106da3c7149
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_87-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 47
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 48
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_87.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_87.ts b/es2panda/test/compiler/ts/new_expression_87.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8b75e0d6044b789c58bebb9dad2e0f23dfa00992
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_87.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: boolean): any ;};
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_88-expected.txt b/es2panda/test/compiler/ts/new_expression_88-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f5d48e20fcc735e8e457dc9e703bf0a73d13e462
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_88-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 47
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 48
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_88.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_88.ts b/es2panda/test/compiler/ts/new_expression_88.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a4b872b515a8de02d781d22a96eca617f0e9d202
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_88.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: boolean): any ;};
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_89-expected.txt b/es2panda/test/compiler/ts/new_expression_89-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1b03167986377941f0547f95efaef6b245404bf7
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_89-expected.txt
@@ -0,0 +1,262 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 47
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 48
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'boolean'. [new_expression_89.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_89.ts b/es2panda/test/compiler/ts/new_expression_89.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c63225d7797e86b430967d824c006f8d6e2bad78
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_89.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: boolean): any ;};
+var a = new foo(false,5);
diff --git a/es2panda/test/compiler/ts/new_expression_9-expected.txt b/es2panda/test/compiler/ts/new_expression_9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..038fd13458ec482ee1e658475ecd422710063e0e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_9-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 45
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_9.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_9.ts b/es2panda/test/compiler/ts/new_expression_9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..55453cf273a553d1443efb5cbfaa059f866128ef
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_9.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: string, b: number): any ;};
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_90-expected.txt b/es2panda/test/compiler/ts/new_expression_90-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cfb16a2a93dbaf9a3f08a9cf1fb0b193b077b363
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_90-expected.txt
@@ -0,0 +1,248 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 47
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 48
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_90.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_90.ts b/es2panda/test/compiler/ts/new_expression_90.ts
new file mode 100644
index 0000000000000000000000000000000000000000..73f901308d08b2944c5c1ae0f4a76b0c030bae3f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_90.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: boolean, b: boolean): any ;};
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/new_expression_91-expected.txt b/es2panda/test/compiler/ts/new_expression_91-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cce958f97bb2653edf57dee1620b9f42935bb53f
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_91-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 25
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 0. [new_expression_91.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_91.ts b/es2panda/test/compiler/ts/new_expression_91.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7d860f96ba790aaf1b78c056852d1e00803e2dc6
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_91.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: any, b: any): any ;};
+var a = new foo();
diff --git a/es2panda/test/compiler/ts/new_expression_92-expected.txt b/es2panda/test/compiler/ts/new_expression_92-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c86dc7535197213586d1f61d6513de5fe39e5420
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_92-expected.txt
@@ -0,0 +1,291 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 25
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              },
+              {
+                "type": "BigIntLiteral",
+                "value": "",
+                "bigint": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 27
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 34
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 35
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 4. [new_expression_92.ts:2:25]
diff --git a/es2panda/test/compiler/ts/new_expression_92.ts b/es2panda/test/compiler/ts/new_expression_92.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0861800d4d721f75887ea8f79769226fb007b532
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_92.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: { new(a: any, b: any): any ;};
+var a = new foo("foo",5,5n,false);
diff --git a/es2panda/test/compiler/ts/new_expression_93-expected.txt b/es2panda/test/compiler/ts/new_expression_93-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b3be0f62e65233558ac448e800fbba14a6373185
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_93-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_93.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_93.ts b/es2panda/test/compiler/ts/new_expression_93.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b2feac1b869b822fb6e364dfb1ef1b8cf23c28ec
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_93.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: string) => any;
+var a = new foo("foo",5);
diff --git a/es2panda/test/compiler/ts/new_expression_94-expected.txt b/es2panda/test/compiler/ts/new_expression_94-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1fdf12998683ff7dd2c13d83b0d99b69d08299a2
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_94-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_94.ts:2:23]
diff --git a/es2panda/test/compiler/ts/new_expression_94.ts b/es2panda/test/compiler/ts/new_expression_94.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fef51d3c821025d744a0c388f1af514ff69beb60
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_94.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: string) => any;
+var a = new foo("foo",false);
diff --git a/es2panda/test/compiler/ts/new_expression_95-expected.txt b/es2panda/test/compiler/ts/new_expression_95-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3bc0a4b402e75d50bebad8c1a7354cbb89bdf08
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_95-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_95.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_95.ts b/es2panda/test/compiler/ts/new_expression_95.ts
new file mode 100644
index 0000000000000000000000000000000000000000..55d02ce20a576abee692bfb5328d3a0524c4db12
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_95.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: string) => any;
+var a = new foo("foo");
diff --git a/es2panda/test/compiler/ts/new_expression_96-expected.txt b/es2panda/test/compiler/ts/new_expression_96-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..caa33c305a09a75785b674ad2fb8d3636fc2d776
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_96-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'number' is not assignable to parameter of type 'string'. [new_expression_96.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_96.ts b/es2panda/test/compiler/ts/new_expression_96.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9d67cc53529fe10910668c49c6833ee521319d92
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_96.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: string) => any;
+var a = new foo(5,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_97-expected.txt b/es2panda/test/compiler/ts/new_expression_97-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..883adbd260c31dd42802a72451b52f20a3c184ce
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_97-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_97.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_97.ts b/es2panda/test/compiler/ts/new_expression_97.ts
new file mode 100644
index 0000000000000000000000000000000000000000..69c53a89d5904d1cdc7fa308cd42ae64605d3f8e
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_97.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: string) => any;
+var a = new foo(5);
diff --git a/es2panda/test/compiler/ts/new_expression_98-expected.txt b/es2panda/test/compiler/ts/new_expression_98-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..01d5d42d23616551e7bb555616b227078d9e4637
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_98-expected.txt
@@ -0,0 +1,247 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Argument of type 'boolean' is not assignable to parameter of type 'string'. [new_expression_98.ts:2:17]
diff --git a/es2panda/test/compiler/ts/new_expression_98.ts b/es2panda/test/compiler/ts/new_expression_98.ts
new file mode 100644
index 0000000000000000000000000000000000000000..593310d0bcb150c2c7c7802748ec6ce07464d2f6
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_98.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: string) => any;
+var a = new foo(false,"foo");
diff --git a/es2panda/test/compiler/ts/new_expression_99-expected.txt b/es2panda/test/compiler/ts/new_expression_99-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..38c71961a8a0db27096f81102d49d0e394d2190a
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_99-expected.txt
@@ -0,0 +1,233 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSAnyKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 10
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 1
+    }
+  }
+}
+TypeError: Expected 2 arguments, but got 1. [new_expression_99.ts:2:9]
diff --git a/es2panda/test/compiler/ts/new_expression_99.ts b/es2panda/test/compiler/ts/new_expression_99.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3fe8f12ca414052d6177dd395698e1c5d6f9e8b6
--- /dev/null
+++ b/es2panda/test/compiler/ts/new_expression_99.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var foo: new (a: string, b: string) => any;
+var a = new foo(false);
diff --git a/es2panda/test/compiler/ts/objectDestructuring-expected.txt b/es2panda/test/compiler/ts/objectDestructuring-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1e4e678832da25c5a9d90bb4fdb8b58c9adb80b4
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring-expected.txt
@@ -0,0 +1,8633 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var1",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "var1",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var2",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "var2",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 17
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 17
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 19
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var1",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 31
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 31
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var2",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 37
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 44
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 22
+              },
+              "end": {
+                "line": 1,
+                "column": 46
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 46
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 8
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 11
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "var3",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 18
+                        }
+                      }
+                    },
+                    {
+                      "type": "OmittedExpression",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 21
+                        }
+                      }
+                    },
+                    {
+                      "type": "OmittedExpression",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 23
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "var4",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 29
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var5",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 35
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "var5",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 42
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 42
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 44
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 53
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 56
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 57
+                        }
+                      }
+                    },
+                    {
+                      "type": "ArrayExpression",
+                      "elements": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 61
+                        }
+                      }
+                    },
+                    {
+                      "type": "ObjectExpression",
+                      "properties": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 63
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 65
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 67
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 72
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 73
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 73
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 47
+              },
+              "end": {
+                "line": 5,
+                "column": 75
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 75
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 75
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 8
+            },
+            "end": {
+              "line": 6,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 8
+            },
+            "end": {
+              "line": 7,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var5",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 8
+            },
+            "end": {
+              "line": 8,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 11
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "var6",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "var6",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 10,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 10,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 10,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 10,
+                                "column": 23
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 23
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 23
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "var7",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "var7",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 10,
+                                "column": 25
+                              },
+                              "end": {
+                                "line": 10,
+                                "column": 29
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 10,
+                                "column": 32
+                              },
+                              "end": {
+                                "line": 10,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 34
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 34
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "var6",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 41
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 45
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 47
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 52
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 52
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "var7",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 54
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 58
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 54
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 64
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 66
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 66
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 66
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 68
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 73
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 77
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var6",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 81
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 85
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 87
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 88
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 10,
+                          "column": 81
+                        },
+                        "end": {
+                          "line": 10,
+                          "column": 88
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var7",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 90
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 94
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 96
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 101
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 10,
+                          "column": 90
+                        },
+                        "end": {
+                          "line": 10,
+                          "column": 101
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 79
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 103
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 73
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 103
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 71
+              },
+              "end": {
+                "line": 10,
+                "column": 105
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 105
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 105
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 1
+            },
+            "end": {
+              "line": 11,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 8
+            },
+            "end": {
+              "line": 11,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 1
+          },
+          "end": {
+            "line": 11,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 8
+            },
+            "end": {
+              "line": 12,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 1
+            },
+            "end": {
+              "line": 13,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 8
+            },
+            "end": {
+              "line": 13,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 1
+          },
+          "end": {
+            "line": 13,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 1
+            },
+            "end": {
+              "line": 14,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 8
+            },
+            "end": {
+              "line": 14,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 1
+          },
+          "end": {
+            "line": 14,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 11
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "prop",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "ArrayPattern",
+                          "elements": [
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "var8",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 16,
+                                    "column": 22
+                                  },
+                                  "end": {
+                                    "line": 16,
+                                    "column": 26
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 16,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 16,
+                                    "column": 30
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 16,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 16,
+                                  "column": 30
+                                }
+                              }
+                            },
+                            {
+                              "type": "AssignmentPattern",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "var9",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 16,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 16,
+                                    "column": 36
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "ObjectExpression",
+                                "properties": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 16,
+                                    "column": 39
+                                  },
+                                  "end": {
+                                    "line": 16,
+                                    "column": 41
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 16,
+                                  "column": 32
+                                },
+                                "end": {
+                                  "line": 16,
+                                  "column": 41
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 42
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 42
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "prop",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 49
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 53
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 16,
+                                  "column": 56
+                                },
+                                "end": {
+                                  "line": 16,
+                                  "column": 61
+                                }
+                              }
+                            },
+                            {
+                              "type": "BooleanLiteral",
+                              "value": true,
+                              "loc": {
+                                "start": {
+                                  "line": 16,
+                                  "column": 63
+                                },
+                                "end": {
+                                  "line": 16,
+                                  "column": 67
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 55
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 68
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 68
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 70
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 70
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 70
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 5
+              },
+              "end": {
+                "line": 16,
+                "column": 72
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 77
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 81
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "prop",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 85
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 89
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 1,
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 92
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 93
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 95
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 96
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 98
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 99
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 91
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 100
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 85
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 100
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 83
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 102
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 77
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 102
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 75
+              },
+              "end": {
+                "line": 16,
+                "column": 104
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 5
+            },
+            "end": {
+              "line": 16,
+              "column": 104
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 105
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var8",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "var6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 8
+            },
+            "end": {
+              "line": 17,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 8
+            },
+            "end": {
+              "line": 18,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 10
+                },
+                "end": {
+                  "line": 19,
+                  "column": 14
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 17
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 24
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 16
+                },
+                "end": {
+                  "line": 19,
+                  "column": 24
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 8
+            },
+            "end": {
+              "line": 19,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 8
+            },
+            "end": {
+              "line": 20,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "var11",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 5
+                },
+                "end": {
+                  "line": 23,
+                  "column": 10
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 12
+                },
+                "end": {
+                  "line": 23,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 5
+              },
+              "end": {
+                "line": 23,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 5
+                },
+                "end": {
+                  "line": 24,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 8
+                },
+                "end": {
+                  "line": 24,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 5
+              },
+              "end": {
+                "line": 24,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 28
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 31
+                },
+                "end": {
+                  "line": 25,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 39
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 22
+          },
+          "end": {
+            "line": 26,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 11
+          },
+          "end": {
+            "line": 22,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var10",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 12
+                },
+                "end": {
+                  "line": 28,
+                  "column": 22
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 5
+            },
+            "end": {
+              "line": 28,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var11",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 12
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "var11",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 12
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 12
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "var12",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 22
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 24
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "var10",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 27
+              },
+              "end": {
+                "line": 29,
+                "column": 32
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 29,
+              "column": 32
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var11",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 1
+            },
+            "end": {
+              "line": 30,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 9
+            },
+            "end": {
+              "line": 30,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 1
+          },
+          "end": {
+            "line": 30,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "var12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 1
+            },
+            "end": {
+              "line": 31,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 19
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 11
+                },
+                "end": {
+                  "line": 31,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 9
+            },
+            "end": {
+              "line": 31,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 31,
+            "column": 1
+          },
+          "end": {
+            "line": 31,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var13",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 12
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "var13",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 12
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 6,
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 16
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var14",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 23
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "var14",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 30
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 30
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "var13",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 43
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 49
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 58
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 58
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 36
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 59
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "var14",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 60
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 67
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 74
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 77
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 83
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 77
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 85
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 85
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 87
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 34
+                },
+                "end": {
+                  "line": 33,
+                  "column": 87
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 32
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var13",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 92
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 97
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 99
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 104
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 92
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 104
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "var14",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 106
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 111
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 114
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 115
+                        }
+                      }
+                    },
+                    {
+                      "type": "NumberLiteral",
+                      "value": 2,
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 117
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 118
+                        }
+                      }
+                    },
+                    {
+                      "type": "NumberLiteral",
+                      "value": 3,
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 120
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 121
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 113
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 122
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 106
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 122
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 90
+              },
+              "end": {
+                "line": 33,
+                "column": 124
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 5
+            },
+            "end": {
+              "line": 33,
+              "column": 124
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 125
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 11
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var15",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "var15",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "var16",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 32
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 32
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "prop",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "var15",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 46
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 51
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 53
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 59
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 60
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 61
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 62
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 64
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 70
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 71
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSMethodSignature",
+                        "computed": false,
+                        "optional": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 72
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 73
+                            }
+                          }
+                        },
+                        "params": [
+                          {
+                            "type": "Identifier",
+                            "name": "a",
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 77
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 83
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 74
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 75
+                              }
+                            }
+                          },
+                          {
+                            "type": "Identifier",
+                            "name": "b",
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 34,
+                                    "column": 88
+                                  },
+                                  "end": {
+                                    "line": 34,
+                                    "column": 94
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 88
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 96
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 85
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 86
+                              }
+                            }
+                          }
+                        ],
+                        "typeAnnotation": {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 99
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 106
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 72
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 107
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 108
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 109
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSArrayType",
+                          "elementType": {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 111
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 117
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 111
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 119
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 108
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 121
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 44
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 121
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 123
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 36
+                },
+                "end": {
+                  "line": 34,
+                  "column": 123
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 5
+              },
+              "end": {
+                "line": 34,
+                "column": 34
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "prop",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 128
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 132
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var15",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 136
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 141
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 12,
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 143
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 145
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 136
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 145
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 147
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 148
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 150
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 155
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 147
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 155
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 157
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 158
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 1,
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 161
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 162
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 164
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 165
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 167
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 168
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 160
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 169
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 157
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 169
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 171
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 172
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "FunctionExpression",
+                        "function": {
+                          "type": "ScriptFunction",
+                          "id": null,
+                          "generator": false,
+                          "async": false,
+                          "expression": false,
+                          "params": [
+                            {
+                              "type": "Identifier",
+                              "name": "a",
+                              "typeAnnotation": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 34,
+                                    "column": 187
+                                  },
+                                  "end": {
+                                    "line": 34,
+                                    "column": 193
+                                  }
+                                }
+                              },
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 184
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 185
+                                }
+                              }
+                            },
+                            {
+                              "type": "Identifier",
+                              "name": "b",
+                              "typeAnnotation": {
+                                "type": "TSArrayType",
+                                "elementType": {
+                                  "type": "TSNumberKeyword",
+                                  "loc": {
+                                    "start": {
+                                      "line": 34,
+                                      "column": 198
+                                    },
+                                    "end": {
+                                      "line": 34,
+                                      "column": 204
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 34,
+                                    "column": 198
+                                  },
+                                  "end": {
+                                    "line": 34,
+                                    "column": 206
+                                  }
+                                }
+                              },
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 195
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 196
+                                }
+                              }
+                            }
+                          ],
+                          "returnType": {
+                            "type": "TSBooleanKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 209
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 216
+                              }
+                            }
+                          },
+                          "body": {
+                            "type": "BlockStatement",
+                            "statements": [
+                              {
+                                "type": "ReturnStatement",
+                                "argument": {
+                                  "type": "BooleanLiteral",
+                                  "value": true,
+                                  "loc": {
+                                    "start": {
+                                      "line": 34,
+                                      "column": 226
+                                    },
+                                    "end": {
+                                      "line": 34,
+                                      "column": 230
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 34,
+                                    "column": 219
+                                  },
+                                  "end": {
+                                    "line": 34,
+                                    "column": 230
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 217
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 232
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 174
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 232
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 174
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 232
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 171
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 232
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 134
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 234
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 128
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 234
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 126
+              },
+              "end": {
+                "line": 34,
+                "column": 236
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 5
+            },
+            "end": {
+              "line": 34,
+              "column": 236
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 237
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "var17",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 15
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 15
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 31
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 32
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 33
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 41
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 43
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 43
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 49
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 51
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 58
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 59
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "d",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 60
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 61
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSVoidKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 63
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 67
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 60
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 69
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 69
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "e",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 74
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 75
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "k",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 79
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 80
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSLiteralType",
+                              "literal": {
+                                "type": "BooleanLiteral",
+                                "value": true,
+                                "loc": {
+                                  "start": {
+                                    "line": 35,
+                                    "column": 82
+                                  },
+                                  "end": {
+                                    "line": 35,
+                                    "column": 86
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 82
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 86
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 35,
+                                "column": 79
+                              },
+                              "end": {
+                                "line": 35,
+                                "column": 87
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "z",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 88
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 89
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSLiteralType",
+                              "literal": {
+                                "type": "StringLiteral",
+                                "value": "",
+                                "loc": {
+                                  "start": {
+                                    "line": 35,
+                                    "column": 91
+                                  },
+                                  "end": {
+                                    "line": 35,
+                                    "column": 96
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 91
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 96
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 35,
+                                "column": 88
+                              },
+                              "end": {
+                                "line": 35,
+                                "column": 98
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 77
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 98
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 74
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 100
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 72
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 100
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 19
+                },
+                "end": {
+                  "line": 35,
+                  "column": 100
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 5
+              },
+              "end": {
+                "line": 35,
+                "column": 17
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 105
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 106
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 108
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 109
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 105
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 109
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 111
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 112
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 114
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 119
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 111
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 119
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 103
+              },
+              "end": {
+                "line": 35,
+                "column": 121
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 5
+            },
+            "end": {
+              "line": 35,
+              "column": 121
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 122
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var18",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 12
+                },
+                "end": {
+                  "line": 37,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 5
+              },
+              "end": {
+                "line": 37,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 5
+            },
+            "end": {
+              "line": 37,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var19",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 12
+                },
+                "end": {
+                  "line": 38,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 5
+              },
+              "end": {
+                "line": 38,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 5
+            },
+            "end": {
+              "line": 38,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var18",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 40,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 40,
+                      "column": 9
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 0,
+                  "loc": {
+                    "start": {
+                      "line": 40,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 40,
+                      "column": 13
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 13
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 4
+                },
+                "end": {
+                  "line": 40,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 20
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 20
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 15
+                },
+                "end": {
+                  "line": 40,
+                  "column": 20
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 2
+            },
+            "end": {
+              "line": 40,
+              "column": 22
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 32
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 35
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 27
+                },
+                "end": {
+                  "line": 40,
+                  "column": 35
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 42
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 48
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 37
+                },
+                "end": {
+                  "line": 40,
+                  "column": 48
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 25
+            },
+            "end": {
+              "line": 40,
+              "column": 50
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 40,
+            "column": 51
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 52
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 9
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 4
+                },
+                "end": {
+                  "line": 41,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 16
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 11
+                },
+                "end": {
+                  "line": 41,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 2
+            },
+            "end": {
+              "line": 41,
+              "column": 18
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 28
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 35
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 23
+                },
+                "end": {
+                  "line": 41,
+                  "column": 35
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 42
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 45
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 37
+                },
+                "end": {
+                  "line": 41,
+                  "column": 45
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 21
+            },
+            "end": {
+              "line": 41,
+              "column": 47
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 1
+          },
+          "end": {
+            "line": 41,
+            "column": 48
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 9
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 4
+                },
+                "end": {
+                  "line": 42,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 16
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 11
+                },
+                "end": {
+                  "line": 42,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 2
+            },
+            "end": {
+              "line": 42,
+              "column": 18
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 28
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 31
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 23
+                },
+                "end": {
+                  "line": 42,
+                  "column": 31
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 21
+            },
+            "end": {
+              "line": 42,
+              "column": 33
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 1
+          },
+          "end": {
+            "line": 42,
+            "column": 34
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 42,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var18",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 43,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 43,
+                      "column": 9
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 4,
+                  "loc": {
+                    "start": {
+                      "line": 43,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 43,
+                      "column": 13
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 13
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 4
+                },
+                "end": {
+                  "line": 43,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 20
+                  }
+                }
+              },
+              "value": {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "var19",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 43,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 43,
+                      "column": 20
+                    }
+                  }
+                },
+                "right": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 43,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 43,
+                      "column": 27
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 27
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 15
+                },
+                "end": {
+                  "line": 43,
+                  "column": 27
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 43,
+              "column": 2
+            },
+            "end": {
+              "line": 43,
+              "column": 29
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 39
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 46
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 34
+                },
+                "end": {
+                  "line": 43,
+                  "column": 46
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 53
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 56
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 48
+                },
+                "end": {
+                  "line": 43,
+                  "column": 56
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 43,
+              "column": 32
+            },
+            "end": {
+              "line": 43,
+              "column": 58
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 43,
+            "column": 1
+          },
+          "end": {
+            "line": 43,
+            "column": 59
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 43,
+          "column": 1
+        },
+        "end": {
+          "line": 43,
+          "column": 60
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var20",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 13
+              },
+              "end": {
+                "line": 45,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 5
+            },
+            "end": {
+              "line": 45,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 45,
+          "column": 1
+        },
+        "end": {
+          "line": 45,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 9
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 4
+                },
+                "end": {
+                  "line": 46,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var20",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 16
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectPattern",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "var18",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 25
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "var18",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 25
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 27
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 11
+                },
+                "end": {
+                  "line": 46,
+                  "column": 27
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 46,
+              "column": 2
+            },
+            "end": {
+              "line": 46,
+              "column": 29
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var19",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 39
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 45
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 34
+                },
+                "end": {
+                  "line": 46,
+                  "column": 45
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var20",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 52
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "var18",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 56
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 61
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "BinaryExpression",
+                      "operator": "+",
+                      "left": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 63
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 64
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "NumberLiteral",
+                        "value": 6,
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 67
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 68
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 63
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 68
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 68
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 54
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 70
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 47
+                },
+                "end": {
+                  "line": 46,
+                  "column": 70
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 46,
+              "column": 32
+            },
+            "end": {
+              "line": 46,
+              "column": 72
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 46,
+            "column": 1
+          },
+          "end": {
+            "line": 46,
+            "column": 73
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 46,
+          "column": 1
+        },
+        "end": {
+          "line": 46,
+          "column": 74
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var21",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [],
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 12
+                },
+                "end": {
+                  "line": 48,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 5
+              },
+              "end": {
+                "line": 48,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 48,
+              "column": 5
+            },
+            "end": {
+              "line": 48,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 48,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 9
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 4
+                },
+                "end": {
+                  "line": 50,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var21",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 11
+                },
+                "end": {
+                  "line": 50,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 2
+            },
+            "end": {
+              "line": 50,
+              "column": 21
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 31
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 7,
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 34
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 26
+                },
+                "end": {
+                  "line": 50,
+                  "column": 34
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 37
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 44
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 36
+                },
+                "end": {
+                  "line": 50,
+                  "column": 44
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 46
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 47
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 50,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 50,
+                          "column": 52
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 50,
+                          "column": 54
+                        },
+                        "end": {
+                          "line": 50,
+                          "column": 59
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 50,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 50,
+                        "column": 59
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 61
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 46
+                },
+                "end": {
+                  "line": 50,
+                  "column": 61
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 24
+            },
+            "end": {
+              "line": 50,
+              "column": 63
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 1
+          },
+          "end": {
+            "line": 50,
+            "column": 64
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 50,
+          "column": 65
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var22",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 12
+                },
+                "end": {
+                  "line": 52,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 5
+              },
+              "end": {
+                "line": 52,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 52,
+              "column": 5
+            },
+            "end": {
+              "line": 52,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 52,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var23",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 12
+                },
+                "end": {
+                  "line": 53,
+                  "column": 22
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 5
+              },
+              "end": {
+                "line": 53,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 53,
+              "column": 5
+            },
+            "end": {
+              "line": 53,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 53,
+          "column": 1
+        },
+        "end": {
+          "line": 53,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "var18",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 5
+                },
+                "end": {
+                  "line": 55,
+                  "column": 10
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 12
+                },
+                "end": {
+                  "line": 55,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 55,
+                "column": 5
+              },
+              "end": {
+                "line": 55,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "var22",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 5
+                },
+                "end": {
+                  "line": 56,
+                  "column": 10
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 12
+                },
+                "end": {
+                  "line": 56,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 56,
+                "column": 5
+              },
+              "end": {
+                "line": 56,
+                "column": 19
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 22
+          },
+          "end": {
+            "line": 57,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 54,
+            "column": 11
+          },
+          "end": {
+            "line": 54,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 57,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 59,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 59,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 59,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 59,
+                    "column": 9
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 4
+                },
+                "end": {
+                  "line": 59,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "RestElement",
+              "argument": {
+                "type": "Identifier",
+                "name": "var21",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 59,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 59,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 11
+                },
+                "end": {
+                  "line": 59,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 2
+            },
+            "end": {
+              "line": 59,
+              "column": 21
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "var23",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 24
+            },
+            "end": {
+              "line": 59,
+              "column": 29
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 59,
+            "column": 1
+          },
+          "end": {
+            "line": 59,
+            "column": 30
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 59,
+          "column": 1
+        },
+        "end": {
+          "line": 59,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var18",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 9
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 4
+                },
+                "end": {
+                  "line": 60,
+                  "column": 9
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var22",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 16
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "var22",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 11
+                },
+                "end": {
+                  "line": 60,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 2
+            },
+            "end": {
+              "line": 60,
+              "column": 18
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "var23",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 21
+            },
+            "end": {
+              "line": 60,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 60,
+            "column": 1
+          },
+          "end": {
+            "line": 60,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 60,
+          "column": 1
+        },
+        "end": {
+          "line": 60,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var24",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 12
+                },
+                "end": {
+                  "line": 62,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 62,
+                "column": 5
+              },
+              "end": {
+                "line": 62,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 62,
+              "column": 5
+            },
+            "end": {
+              "line": 62,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 62,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var25",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 12
+                },
+                "end": {
+                  "line": 63,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 63,
+                "column": 5
+              },
+              "end": {
+                "line": 63,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 5
+            },
+            "end": {
+              "line": 63,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 63,
+          "column": 1
+        },
+        "end": {
+          "line": 63,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var26",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 12
+                },
+                "end": {
+                  "line": 64,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 5
+              },
+              "end": {
+                "line": 64,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 64,
+              "column": 5
+            },
+            "end": {
+              "line": 64,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 64,
+          "column": 1
+        },
+        "end": {
+          "line": 64,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var27",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 12
+                },
+                "end": {
+                  "line": 65,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 65,
+                "column": 5
+              },
+              "end": {
+                "line": 65,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 65,
+              "column": 5
+            },
+            "end": {
+              "line": 65,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 65,
+          "column": 1
+        },
+        "end": {
+          "line": 65,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var27",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 67,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 67,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "var26",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 67,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 67,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 67,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 67,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 24
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "Identifier",
+                        "name": "var25",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 67,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 67,
+                            "column": 32
+                          }
+                        }
+                      },
+                      {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "var24",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 67,
+                              "column": 34
+                            },
+                            "end": {
+                              "line": 67,
+                              "column": 39
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "NumberLiteral",
+                          "value": 8,
+                          "loc": {
+                            "start": {
+                              "line": 67,
+                              "column": 42
+                            },
+                            "end": {
+                              "line": 67,
+                              "column": 43
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 67,
+                            "column": 34
+                          },
+                          "end": {
+                            "line": 67,
+                            "column": 43
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 44
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 67,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 67,
+                    "column": 45
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 4
+                },
+                "end": {
+                  "line": 67,
+                  "column": 45
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 67,
+              "column": 2
+            },
+            "end": {
+              "line": 67,
+              "column": 47
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var27",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 67,
+                    "column": 52
+                  },
+                  "end": {
+                    "line": 67,
+                    "column": 57
+                  }
+                }
+              },
+              "value": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "BooleanLiteral",
+                    "value": false,
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 60
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 65
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 67,
+                            "column": 68
+                          },
+                          "end": {
+                            "line": 67,
+                            "column": 73
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 74
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 67,
+                    "column": 59
+                  },
+                  "end": {
+                    "line": 67,
+                    "column": 75
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 52
+                },
+                "end": {
+                  "line": 67,
+                  "column": 75
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 67,
+              "column": 50
+            },
+            "end": {
+              "line": 67,
+              "column": 77
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 67,
+            "column": 1
+          },
+          "end": {
+            "line": 67,
+            "column": 78
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 67,
+          "column": 1
+        },
+        "end": {
+          "line": 67,
+          "column": 78
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var28",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 12
+                },
+                "end": {
+                  "line": 69,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 5
+              },
+              "end": {
+                "line": 69,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 69,
+              "column": 5
+            },
+            "end": {
+              "line": 69,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 69,
+          "column": 1
+        },
+        "end": {
+          "line": 69,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var29",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 70,
+                  "column": 12
+                },
+                "end": {
+                  "line": 70,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 70,
+                "column": 5
+              },
+              "end": {
+                "line": 70,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 70,
+              "column": 5
+            },
+            "end": {
+              "line": 70,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 70,
+          "column": 1
+        },
+        "end": {
+          "line": 70,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var30",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 71,
+                "column": 5
+              },
+              "end": {
+                "line": 71,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 71,
+                "column": 13
+              },
+              "end": {
+                "line": 71,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 71,
+              "column": 5
+            },
+            "end": {
+              "line": 71,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 71,
+          "column": 1
+        },
+        "end": {
+          "line": 71,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var30",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 9
+                  }
+                }
+              },
+              "value": {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var29",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 73,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 73,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "AssignmentPattern",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "var29",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 73,
+                              "column": 13
+                            },
+                            "end": {
+                              "line": 73,
+                              "column": 18
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 73,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 73,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 73,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 73,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 26
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var28",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 73,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 73,
+                            "column": 33
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "var28",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 73,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 73,
+                            "column": 33
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 33
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 73,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 73,
+                      "column": 35
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "var28",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 73,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 73,
+                            "column": 45
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 9,
+                        "loc": {
+                          "start": {
+                            "line": 73,
+                            "column": 47
+                          },
+                          "end": {
+                            "line": 73,
+                            "column": 48
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 40
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 48
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 73,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 73,
+                      "column": 50
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 50
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 4
+                },
+                "end": {
+                  "line": 73,
+                  "column": 50
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 73,
+              "column": 2
+            },
+            "end": {
+              "line": 73,
+              "column": 52
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "var30",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 57
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 62
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "var28",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 66
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 71
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 10,
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 73
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 75
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 73,
+                        "column": 66
+                      },
+                      "end": {
+                        "line": 73,
+                        "column": 75
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "var29",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 77
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 82
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 73,
+                          "column": 84
+                        },
+                        "end": {
+                          "line": 73,
+                          "column": 89
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 73,
+                        "column": 77
+                      },
+                      "end": {
+                        "line": 73,
+                        "column": 89
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 64
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 91
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 57
+                },
+                "end": {
+                  "line": 73,
+                  "column": 91
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 73,
+              "column": 55
+            },
+            "end": {
+              "line": 73,
+              "column": 93
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 73,
+            "column": 1
+          },
+          "end": {
+            "line": 73,
+            "column": 94
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 73,
+          "column": 1
+        },
+        "end": {
+          "line": 73,
+          "column": 95
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 73,
+      "column": 95
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/objectDestructuring.ts b/es2panda/test/compiler/ts/objectDestructuring.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2bf509ab671f7618d67b72f17b9d1a2d5522faa1
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring.ts
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { var1, var2 } = { var1: 5, var2: "foo" };
+var1 = 3;
+var2 = "bar";
+
+var { prop: [var3, , , var4], var5 = true } = { prop: [1, [], {}, "foo"] }
+var3 = 12;
+var4 = "baz";
+var5 = false;
+
+var { prop: { var6 = 3, var7 = "" } = { var6: "foo", var7: true } } = { prop: { var6: 1, var7: "bar" } }
+var6 = 1;
+var6 = "baz";
+var7 = false;
+var7 = "baz";
+
+var { prop: { prop: [var8 = 1, var9 = {}] } = { prop: ["foo", true] } } = { prop: { prop: [1, 2, 3] } };
+var8 = var6;
+var9 = 1;
+var9 = { a: 1, b: "foo" };
+var9 = false;
+
+interface interface1 {
+    var11: number,
+    b: string,
+    (a: number, b: string[]): boolean;
+}
+
+var var10: interface1;
+var { var11, ...var12 } = var10;
+var11 = 12;
+var12 = { b: "foo" };
+
+var { var13 = 6, var14 = true }: { var13: number | string, var14: boolean | number[] } = { var13: "foo", var14: [1, 2, 3] };
+var { prop: { var15, ...var16 } }: { prop: { var15: number, a: string, b(a: number, b: number[]): boolean, c: number[] } } = { prop: { var15: 12, a: "foo", c: [1, 2, 3], b: function (a: number, b: number[]): boolean { return true } } };
+var { ...var17 }: { a: number, b: string } | { c: boolean, d: void } | { e: { k: true, z: "foo" } } = { a: 5, b: "foo" };
+
+var var18: number;
+var var19: boolean;
+
+({ var18 = 0, var19 } = { var18: 1, var19: true });
+({ var18, var19 } = { var19: false, var18: 3 });
+({ var18, var18 } = { var18: 2 });
+({ var18 = 4, var19 = true } = { var19: false, var18: 5 });
+
+var var20 = {};
+({ var19, var20: { var18 } } = { var19: true, var20: { var18: 5 + 6 } });
+
+var var21: {};
+
+({ var18, ...var21 } = { var18: 7, a: false, b: { c: "foo" } });
+
+var var22: string;
+var var23: interface2;
+interface interface2 {
+    var18: number,
+    var22: string;
+}
+
+({ var18, ...var21 } = var23);
+({ var18, var22 } = var23);
+
+var var24: number;
+var var25: string;
+var var26: boolean;
+var var27: any;
+
+({ var27: [var26 = true, [var25, var24 = 8]] } = { var27: [false, ["foo"]] })
+
+var var28: number;
+var var29: string;
+var var30 = {};
+
+({ var30: { var29 = "foo", var28 } = { var28: 9 } } = { var30: { var28: 10, var29: "bar" } });
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring1-expected.txt b/es2panda/test/compiler/ts/objectDestructuring1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b532c3d276b1bb794aaedb7ac3412ada9788b701
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring1-expected.txt
@@ -0,0 +1,121 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 8
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 13
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 16
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [objectDestructuring1.ts:1:7]
diff --git a/es2panda/test/compiler/ts/objectDestructuring1.ts b/es2panda/test/compiler/ts/objectDestructuring1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c5f5e4e3454fdfeb94f921810b1ee39ef4827aa2
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a } = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring10-expected.txt b/es2panda/test/compiler/ts/objectDestructuring10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3e971c0553d023a8edc4252143b0c52cb139adf6
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring10-expected.txt
@@ -0,0 +1,382 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 13
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 16
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "NumberLiteral",
+                          "value": 1,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 27
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 32
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 36
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 38
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 38
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 40
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 49
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 49
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 43
+              },
+              "end": {
+                "line": 1,
+                "column": 51
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 51
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 51
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 51
+    }
+  }
+}
+TypeError: Property 'a' does not exist on type '{ a: number; b: boolean; } | number [objectDestructuring10.ts:1:12]
diff --git a/es2panda/test/compiler/ts/objectDestructuring10.ts b/es2panda/test/compiler/ts/objectDestructuring10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..66c1be60dd8bba097e771c3e2ab04a2f23d8fcc5
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring10.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: { a, b } = { a: 1, b: true } } = { a: 5 }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring11-expected.txt b/es2panda/test/compiler/ts/objectDestructuring11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e5b07d4bd1b69bdfc11f2d143189822658d356dc
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring11-expected.txt
@@ -0,0 +1,383 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 13
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 16
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 31
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 31
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 35
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 45
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 46
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 52
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 54
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 54
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 38
+              },
+              "end": {
+                "line": 1,
+                "column": 56
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 56
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 57
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 57
+    }
+  }
+}
+TypeError: Property 'a' does not exist on type '{ b: string; } | { b: boolean; } [objectDestructuring11.ts:1:12]
diff --git a/es2panda/test/compiler/ts/objectDestructuring11.ts b/es2panda/test/compiler/ts/objectDestructuring11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a4d7ae316d63a0b6207861d912695a37f3f676dc
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring11.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: { a, b } = { b: "foo" } } = { a: { b: true } };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring12-expected.txt b/es2panda/test/compiler/ts/objectDestructuring12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e4ce952594bc15ff23d9b5366dda7361ee7b7148
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring12-expected.txt
@@ -0,0 +1,513 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "a",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "BigIntLiteral",
+                            "value": "",
+                            "bigint": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 16
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 18
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 18
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 18
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 21
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 21
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 21
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 28
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 36
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 38
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 38
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 40
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 51
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 53
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 54
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 54
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 56
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 57
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 59
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 63
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 56
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 63
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 65
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 65
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 43
+              },
+              "end": {
+                "line": 1,
+                "column": 67
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 67
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 68
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'number | bigint'. [objectDestructuring12.ts:2:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring12.ts b/es2panda/test/compiler/ts/objectDestructuring12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d6ed9b539d5a4ab37a66036ef1a18770ad4ef805
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring12.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: { a = 5n, b } = { b: "foo" } } = { a: { a: 5, b: true } };
+a = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring13-expected.txt b/es2panda/test/compiler/ts/objectDestructuring13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..025754ba136bd0aa73a97f4837895b0698f25f11
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring13-expected.txt
@@ -0,0 +1,438 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 14
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 22
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 32
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 35
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 39
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 40
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ObjectExpression",
+                        "properties": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 42
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 44
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 44
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 53
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 55
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 19
+              },
+              "end": {
+                "line": 1,
+                "column": 57
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 57
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 58
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type '{ b: bigint; c: { a: { }; b: boolean; }; }'. [objectDestructuring13.ts:2:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring13.ts b/es2panda/test/compiler/ts/objectDestructuring13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..10743f14b57824025b1e7305fa5b25e6ace501b7
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring13.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a, ...b } = { a: 5, b: 5n, c: { a: {}, b: true } };
+b = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring14-expected.txt b/es2panda/test/compiler/ts/objectDestructuring14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0fe59e893e872c476b317b51d4a26c6ef9020056
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring14-expected.txt
@@ -0,0 +1,217 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSVoidKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 11
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 13
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 16
+              },
+              "end": {
+                "line": 2,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type 'void' is not assignable to type '{ }'. [objectDestructuring14.ts:3:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring14.ts b/es2panda/test/compiler/ts/objectDestructuring14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ddd2f26e2e6d04e0835e3ecd71c9bf703cf49301
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring14.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var b: void;
+var { ...a } = {};
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring15-expected.txt b/es2panda/test/compiler/ts/objectDestructuring15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4c2d9a4e54eba0517a90f32dff61a963e052434
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring15-expected.txt
@@ -0,0 +1,301 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 36
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 23
+                },
+                "end": {
+                  "line": 1,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 21
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 42
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 12,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 46
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 39
+              },
+              "end": {
+                "line": 1,
+                "column": 48
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 48
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 49
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 49
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectDestructuring15.ts:1:7]
diff --git a/es2panda/test/compiler/ts/objectDestructuring15.ts b/es2panda/test/compiler/ts/objectDestructuring15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0e5c90f76af7ba96434767254356d4ebc205806
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring15.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a = "foo", b }: { a: number } = { a: 12 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring16-expected.txt b/es2panda/test/compiler/ts/objectDestructuring16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a98420ec877fa945b9df7623d8276b01877d11a7
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring16-expected.txt
@@ -0,0 +1,373 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 43
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 56
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 23
+                },
+                "end": {
+                  "line": 1,
+                  "column": 56
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 21
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 61
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 62
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 12,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 64
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 66
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 61
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 66
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 59
+              },
+              "end": {
+                "line": 1,
+                "column": 68
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 68
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 69
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 69
+    }
+  }
+}
+TypeError: Type '{ a: number; }' is not assignable to type '{ a: number | string; b: number; }'. [objectDestructuring16.ts:1:5]
diff --git a/es2panda/test/compiler/ts/objectDestructuring16.ts b/es2panda/test/compiler/ts/objectDestructuring16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4784af8fc81932a0a4571eb31b200ddc5a89a43c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring16.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a = "foo", b }: { a: number | string, b: number } = { a: 12 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring17-expected.txt b/es2panda/test/compiler/ts/objectDestructuring17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3cbed746605e26df580db93227c916499d051567
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring17-expected.txt
@@ -0,0 +1,419 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 43
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 56
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 23
+                },
+                "end": {
+                  "line": 1,
+                  "column": 56
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 21
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 61
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 62
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 12,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 64
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 66
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 61
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 66
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 68
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 69
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 71
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 75
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 68
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 75
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 59
+              },
+              "end": {
+                "line": 1,
+                "column": 77
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 77
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 78
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 78
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'number'. [objectDestructuring17.ts:1:68]
diff --git a/es2panda/test/compiler/ts/objectDestructuring17.ts b/es2panda/test/compiler/ts/objectDestructuring17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b17f47c3805011c02b4fb6897eb5339499bdd7b9
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring17.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a = "foo", b }: { a: number | string, b: number } = { a: 12, b: true };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring18-expected.txt b/es2panda/test/compiler/ts/objectDestructuring18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..647af818cf712acd5b5e03083d6bdf05464113b3
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring18-expected.txt
@@ -0,0 +1,392 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 11
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 27
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 39
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 39
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 44
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 45
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 47
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 44
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 55
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 15
+                },
+                "end": {
+                  "line": 1,
+                  "column": 55
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 13
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 63
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 68
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 60
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 68
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 58
+              },
+              "end": {
+                "line": 1,
+                "column": 70
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 70
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 71
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 71
+    }
+  }
+}
+TypeError: Property 'b' does not exist on type '{ a: number; b: string; } | { a: string; } [objectDestructuring18.ts:1:10]
diff --git a/es2panda/test/compiler/ts/objectDestructuring18.ts b/es2panda/test/compiler/ts/objectDestructuring18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..550f630de17b46d466a64224e0aa2196ba4e9b6b
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring18.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a, b }: { a: number, b: string } | { a: string } = { a: "foo" };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring19-expected.txt b/es2panda/test/compiler/ts/objectDestructuring19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21d791f98874d5750a4f494052edb43ede189ab7
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring19-expected.txt
@@ -0,0 +1,492 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 8
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 25
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 31
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 33
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 40
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 42
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 44
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 50
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 41
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 51
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 57
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 58
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 60
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 66
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 57
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 67
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 68
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 69
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSBooleanKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 71
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 78
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 68
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 80
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 80
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 52
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 82
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 82
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 85
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 91
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 12
+                },
+                "end": {
+                  "line": 1,
+                  "column": 91
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 96
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 97
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 12,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 99
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 101
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 96
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 101
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 94
+              },
+              "end": {
+                "line": 1,
+                "column": 103
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 103
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 104
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 104
+    }
+  }
+}
+TypeError: Property 'a' does not exist on type '{ a: number; } | { a: number; b: string; c: { a: number; b: boolean; }; } | number [objectDestructuring19.ts:1:7]
diff --git a/es2panda/test/compiler/ts/objectDestructuring19.ts b/es2panda/test/compiler/ts/objectDestructuring19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bdb9e4d5ca86b5d10a799c1fd6c73e568e17de04
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring19.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a }: { a: number } | { a: number, b: string, c: { a: number, b: boolean } } | number = { a: 12 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring2-expected.txt b/es2panda/test/compiler/ts/objectDestructuring2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3afeb1705435cf564c0e9aa58e033de6db13e663
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring2-expected.txt
@@ -0,0 +1,214 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 8
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 23
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 26
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 29
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 13
+              },
+              "end": {
+                "line": 1,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 31
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 32
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 32
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'b' does not exist in type '{ a: any; }'. [objectDestructuring2.ts:1:25]
diff --git a/es2panda/test/compiler/ts/objectDestructuring2.ts b/es2panda/test/compiler/ts/objectDestructuring2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7bafb0bb1166ae0b06a177e42bf499116619653a
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a } = { a: "foo", b: 5 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring20-expected.txt b/es2panda/test/compiler/ts/objectDestructuring20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f491b5db81903fc5e665c89821f07cb347e3f7f6
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring20-expected.txt
@@ -0,0 +1,725 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSVoidKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 14
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 14
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 21
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 31
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 36
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 39
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 45
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 36
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 46
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 47
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 48
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 56
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 47
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 57
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 58
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 2,
+                                  "column": 63
+                                },
+                                "end": {
+                                  "line": 2,
+                                  "column": 64
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 2,
+                                  "column": 66
+                                },
+                                "end": {
+                                  "line": 2,
+                                  "column": 72
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 63
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 73
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 2,
+                                  "column": 74
+                                },
+                                "end": {
+                                  "line": 2,
+                                  "column": 75
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSBooleanKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 2,
+                                  "column": 77
+                                },
+                                "end": {
+                                  "line": 2,
+                                  "column": 84
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 74
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 86
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 86
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 58
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 88
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 88
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 93
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 94
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 96
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 102
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 93
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 103
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "r",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 104
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 105
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 107
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 114
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 104
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 116
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 91
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 116
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 18
+                },
+                "end": {
+                  "line": 2,
+                  "column": 116
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 16
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 121
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 122
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 12,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 124
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 126
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 121
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 126
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 119
+              },
+              "end": {
+                "line": 2,
+                "column": 128
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 128
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 129
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type 'void' is not assignable to type '{ } | { b: string; c: { a: number; b: boolean; }; } | { r: boolean; }'. [objectDestructuring20.ts:3:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring20.ts b/es2panda/test/compiler/ts/objectDestructuring20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c39d53783d0f56cb8782cfc168af0b70267125d
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring20.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var c: void;
+var { a, ...b }: { a: number } | { a: number, b: string, c: { a: number, b: boolean } } | { a: number, r: boolean } = { a: 12 };
+b = c;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring21-expected.txt b/es2panda/test/compiler/ts/objectDestructuring21-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ea6f164050fcd98c7920b4b1685f1139246ac33e
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring21-expected.txt
@@ -0,0 +1,326 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 8
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 13
+              },
+              "end": {
+                "line": 2,
+                "column": 14
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 14
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'string'. [objectDestructuring21.ts:3:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring21.ts b/es2panda/test/compiler/ts/objectDestructuring21.ts
new file mode 100644
index 0000000000000000000000000000000000000000..643b32b11f0d2877c816556b3ebba01a0262f9ad
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring21.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { b: number, c: string };
+var { c } = a;
+c = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring22-expected.txt b/es2panda/test/compiler/ts/objectDestructuring22-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cf30baf97d351d08739d10f297ccfa20bb6f183b
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring22-expected.txt
@@ -0,0 +1,438 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 16
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSStringKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "c",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 26
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 29
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 35
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 26
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 37
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 39
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 39
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 48
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 48
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 13
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 20
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 23
+              },
+              "end": {
+                "line": 2,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 25
+    }
+  }
+}
+TypeError: Property 'a' does not exist on type '{ a: { b: string; c: number; }; } | number [objectDestructuring22.ts:2:7]
diff --git a/es2panda/test/compiler/ts/objectDestructuring22.ts b/es2panda/test/compiler/ts/objectDestructuring22.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5038e166e1ea2091810e1aa24443059c58204673
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring22.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: { b: string, c: number } } | number;
+var { a: { b, c } } = a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring23-expected.txt b/es2panda/test/compiler/ts/objectDestructuring23-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..554707d24ecbf339872b7cd84f350d273a3baf77
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring23-expected.txt
@@ -0,0 +1,377 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTupleType",
+                          "elementTypes": [
+                            {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 19
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 26
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 27
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 34
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 34
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayPattern",
+                        "elements": [
+                          {
+                            "type": "Identifier",
+                            "name": "a",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 16
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 17
+                              }
+                            }
+                          },
+                          {
+                            "type": "Identifier",
+                            "name": "b",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 20
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 21
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 21
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 23
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 28
+              },
+              "end": {
+                "line": 2,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 30
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type '{ b: { c: [number, number]; }; }', but here has type 'number'. [objectDestructuring23.ts:2:16]
diff --git a/es2panda/test/compiler/ts/objectDestructuring23.ts b/es2panda/test/compiler/ts/objectDestructuring23.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c8b6219a0c698053e56bd99698d2a7d7f7ee8834
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring23.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { b: { c: [number, number] } };
+var { b: { c: [a, b] } } = a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring24-expected.txt b/es2panda/test/compiler/ts/objectDestructuring24-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b473e13622db264af707b78425c1aaabc3fbbee
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring24-expected.txt
@@ -0,0 +1,565 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTupleType",
+                          "elementTypes": [
+                            {
+                              "type": "TSUnionType",
+                              "types": [
+                                {
+                                  "type": "TSStringKeyword",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 36
+                                    }
+                                  }
+                                },
+                                {
+                                  "type": "TSNumberKeyword",
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 39
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 45
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 30
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 46
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSBooleanKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 47
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 54
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 47
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 57
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 57
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 59
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 61
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 11
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "t",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayPattern",
+                        "elements": [
+                          {
+                            "type": "Identifier",
+                            "name": "d",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 20
+                              }
+                            }
+                          },
+                          {
+                            "type": "Identifier",
+                            "name": "e",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 23
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 26
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 26
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 28
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 31
+              },
+              "end": {
+                "line": 2,
+                "column": 32
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 32
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'string | number'. [objectDestructuring24.ts:3:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring24.ts b/es2panda/test/compiler/ts/objectDestructuring24.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d339138945255d543dd179a75e863e6fe062ba02
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring24.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { b: number, c: { t: [string | number, boolean[]] } };
+var { b, c: { t: [d, e] } } = a;
+d = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring25-expected.txt b/es2panda/test/compiler/ts/objectDestructuring25-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fa77347379dd5eb07e1fbfbbe8c62cbef49346a0
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring25-expected.txt
@@ -0,0 +1,737 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 15
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 12
+              },
+              "end": {
+                "line": 1,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypeLiteral",
+          "members": [
+            {
+              "type": "TSPropertySignature",
+              "computed": false,
+              "optional": false,
+              "readonly": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 28
+                },
+                "end": {
+                  "line": 1,
+                  "column": 38
+                }
+              }
+            },
+            {
+              "type": "TSPropertySignature",
+              "computed": false,
+              "optional": false,
+              "readonly": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 40
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSTupleType",
+                "elementTypes": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 50
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 58
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 58
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 39
+                },
+                "end": {
+                  "line": 1,
+                  "column": 60
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 26
+            },
+            "end": {
+              "line": 1,
+              "column": 60
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 15
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 18
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 18
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "NumberLiteral",
+                          "value": 1,
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 25
+                            }
+                          }
+                        },
+                        {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 32
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 33
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 33
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 35
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 36
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 61
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 16
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 19
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 23
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "d",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 27
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 27
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 29
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 32
+                },
+                "end": {
+                  "line": 5,
+                  "column": 33
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 36
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 39
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 42
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 43
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 32
+              },
+              "end": {
+                "line": 5,
+                "column": 44
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 44
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'string'. [objectDestructuring25.ts:6:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring25.ts b/es2panda/test/compiler/ts/objectDestructuring25.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88c79411ba8d645d534e87d43d4658561de99671
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring25.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function a(a: number[]): { b: number, c: [number, string] } {
+    return { b: 5, c: [1, "foo"] };
+}
+
+var { b = "foo", c: [c, d] } = a([1, 2, 3]);
+d = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring26-expected.txt b/es2panda/test/compiler/ts/objectDestructuring26-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2e76ae613500a7bf9cb0d86e1063e018e8a6447c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring26-expected.txt
@@ -0,0 +1,772 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "ArrayPattern",
+                            "elements": [
+                              {
+                                "type": "AssignmentPattern",
+                                "left": {
+                                  "type": "ObjectPattern",
+                                  "properties": [
+                                    {
+                                      "type": "Property",
+                                      "method": false,
+                                      "shorthand": true,
+                                      "computed": false,
+                                      "key": {
+                                        "type": "Identifier",
+                                        "name": "r",
+                                        "decorators": [],
+                                        "loc": {
+                                          "start": {
+                                            "line": 1,
+                                            "column": 18
+                                          },
+                                          "end": {
+                                            "line": 1,
+                                            "column": 19
+                                          }
+                                        }
+                                      },
+                                      "value": {
+                                        "type": "Identifier",
+                                        "name": "r",
+                                        "decorators": [],
+                                        "loc": {
+                                          "start": {
+                                            "line": 1,
+                                            "column": 18
+                                          },
+                                          "end": {
+                                            "line": 1,
+                                            "column": 19
+                                          }
+                                        }
+                                      },
+                                      "kind": "init",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 18
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 19
+                                        }
+                                      }
+                                    },
+                                    {
+                                      "type": "Property",
+                                      "method": false,
+                                      "shorthand": true,
+                                      "computed": false,
+                                      "key": {
+                                        "type": "Identifier",
+                                        "name": "k",
+                                        "decorators": [],
+                                        "loc": {
+                                          "start": {
+                                            "line": 1,
+                                            "column": 21
+                                          },
+                                          "end": {
+                                            "line": 1,
+                                            "column": 22
+                                          }
+                                        }
+                                      },
+                                      "value": {
+                                        "type": "Identifier",
+                                        "name": "k",
+                                        "decorators": [],
+                                        "loc": {
+                                          "start": {
+                                            "line": 1,
+                                            "column": 21
+                                          },
+                                          "end": {
+                                            "line": 1,
+                                            "column": 22
+                                          }
+                                        }
+                                      },
+                                      "kind": "init",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 21
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 22
+                                        }
+                                      }
+                                    }
+                                  ],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 16
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 24
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "ObjectExpression",
+                                  "properties": [
+                                    {
+                                      "type": "Property",
+                                      "method": false,
+                                      "shorthand": false,
+                                      "computed": false,
+                                      "key": {
+                                        "type": "Identifier",
+                                        "name": "er",
+                                        "decorators": [],
+                                        "loc": {
+                                          "start": {
+                                            "line": 1,
+                                            "column": 29
+                                          },
+                                          "end": {
+                                            "line": 1,
+                                            "column": 31
+                                          }
+                                        }
+                                      },
+                                      "value": {
+                                        "type": "NumberLiteral",
+                                        "value": 5,
+                                        "loc": {
+                                          "start": {
+                                            "line": 1,
+                                            "column": 33
+                                          },
+                                          "end": {
+                                            "line": 1,
+                                            "column": 34
+                                          }
+                                        }
+                                      },
+                                      "kind": "init",
+                                      "loc": {
+                                        "start": {
+                                          "line": 1,
+                                          "column": 29
+                                        },
+                                        "end": {
+                                          "line": 1,
+                                          "column": 34
+                                        }
+                                      }
+                                    }
+                                  ],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 27
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 36
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 16
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 36
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 37
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "ArrayExpression",
+                            "elements": [
+                              {
+                                "type": "StringLiteral",
+                                "value": "",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 41
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 46
+                                  }
+                                }
+                              },
+                              {
+                                "type": "BooleanLiteral",
+                                "value": true,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 48
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 52
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 53
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 53
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 53
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 55
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "z",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 61
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "NumberLiteral",
+                          "value": 5,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 63
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 60
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 64
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 66
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 67
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "NumberLiteral",
+                              "value": 2,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 70
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 71
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 73
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 78
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 69
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 79
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 66
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 79
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 58
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 81
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 81
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 81
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 83
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 88
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 89
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "k",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 93
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 94
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 96
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 97
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 93
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 97
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 99
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 100
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "BooleanLiteral",
+                            "value": true,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 103
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 107
+                              }
+                            }
+                          },
+                          {
+                            "type": "BigIntLiteral",
+                            "value": "",
+                            "bigint": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 109
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 111
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 102
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 112
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 99
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 112
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 91
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 114
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 88
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 114
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "k",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 116
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 117
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 119
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 120
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 116
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 120
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 86
+              },
+              "end": {
+                "line": 1,
+                "column": 122
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 122
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 123
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 1
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'er' does not exist in type '{ r: any; k: any; }'. [objectDestructuring26.ts:1:29]
diff --git a/es2panda/test/compiler/ts/objectDestructuring26.ts b/es2panda/test/compiler/ts/objectDestructuring26.ts
new file mode 100644
index 0000000000000000000000000000000000000000..564ecef5068ebe2893df0790da7c75af7e49b30f
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring26.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: { b: [{ r, k } = { er: 5 }] = ["foo", true] } = { z: 5, b: [2, "foo"] } } = { a: { k: 2, b: [true, 2n] }, k: 5 };
diff --git a/es2panda/test/compiler/ts/objectDestructuring27-expected.txt b/es2panda/test/compiler/ts/objectDestructuring27-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8ddfa449998fdad162d2485be084687abba02f3b
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring27-expected.txt
@@ -0,0 +1,658 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSVoidKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "ArrayPattern",
+                            "elements": [
+                              {
+                                "type": "AssignmentPattern",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "c",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 4,
+                                      "column": 16
+                                    },
+                                    "end": {
+                                      "line": 4,
+                                      "column": 17
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "NumberLiteral",
+                                  "value": 2,
+                                  "loc": {
+                                    "start": {
+                                      "line": 4,
+                                      "column": 20
+                                    },
+                                    "end": {
+                                      "line": 4,
+                                      "column": 21
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 16
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "d",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 23
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 24
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "ArrayExpression",
+                            "elements": [
+                              {
+                                "type": "StringLiteral",
+                                "value": "",
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 34
+                                  }
+                                }
+                              },
+                              {
+                                "type": "BooleanLiteral",
+                                "value": true,
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 36
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 40
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 28
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 41
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 41
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 48
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 49
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "NumberLiteral",
+                              "value": 2,
+                              "loc": {
+                                "start": {
+                                  "line": 4,
+                                  "column": 52
+                                },
+                                "end": {
+                                  "line": 4,
+                                  "column": 53
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 4,
+                                  "column": 55
+                                },
+                                "end": {
+                                  "line": 4,
+                                  "column": 60
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 51
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 61
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 61
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 63
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 63
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 63
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 65
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 70
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 71
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "k",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 75
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 76
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 78
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 79
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 75
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 79
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 81
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 82
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "BooleanLiteral",
+                            "value": true,
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 85
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 89
+                              }
+                            }
+                          },
+                          {
+                            "type": "BigIntLiteral",
+                            "value": "",
+                            "bigint": "",
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 91
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 93
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 84
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 94
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 81
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 94
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 73
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 96
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 70
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 96
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "t",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 98
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 99
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 101
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 102
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 98
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 102
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 68
+              },
+              "end": {
+                "line": 4,
+                "column": 104
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 104
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 105
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 't' does not exist in type '{ a?: { b: [number, string]; }; }'. [objectDestructuring27.ts:4:98]
diff --git a/es2panda/test/compiler/ts/objectDestructuring27.ts b/es2panda/test/compiler/ts/objectDestructuring27.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ad7bd14f940a2fd19f072cdd29717bb1f6ad6dde
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring27.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var e: void;
+var { a: { b: [c = 2, d] = ["foo", true] } = { b: [2, "foo"] } } = { a: { k: 2, b: [true, 2n] }, t: 6 };
+
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring28-expected.txt b/es2panda/test/compiler/ts/objectDestructuring28-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7116f9a2187a9f6c910f40a798a3573d75fea83a
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring28-expected.txt
@@ -0,0 +1,805 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSVoidKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "u",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "ArrayPattern",
+                            "elements": [
+                              {
+                                "type": "AssignmentPattern",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "c",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 4,
+                                      "column": 16
+                                    },
+                                    "end": {
+                                      "line": 4,
+                                      "column": 17
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "Identifier",
+                                  "name": "u",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 4,
+                                      "column": 20
+                                    },
+                                    "end": {
+                                      "line": 4,
+                                      "column": 21
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 16
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "d",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 23
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 24
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "ArrayExpression",
+                            "elements": [
+                              {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 30
+                                  }
+                                }
+                              },
+                              {
+                                "type": "BooleanLiteral",
+                                "value": true,
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 36
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 28
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 37
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 37
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 44
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 45
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "BigIntLiteral",
+                              "value": "",
+                              "bigint": "",
+                              "loc": {
+                                "start": {
+                                  "line": 4,
+                                  "column": 48
+                                },
+                                "end": {
+                                  "line": 4,
+                                  "column": 50
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 47
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 51
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 44
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 51
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 53
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 53
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 53
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 55
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 61
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "k",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 65
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 66
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 68
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 69
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 65
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 69
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 71
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 72
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 75
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 80
+                              }
+                            }
+                          },
+                          {
+                            "type": "BigIntLiteral",
+                            "value": "",
+                            "bigint": "",
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 82
+                              },
+                              "end": {
+                                "line": 4,
+                                "column": 84
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 74
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 85
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 71
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 85
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 63
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 87
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 60
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 87
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 58
+              },
+              "end": {
+                "line": 4,
+                "column": 89
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 89
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 90
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'void' is not assignable to type 'bigint | string | number | { a: number; b: string; }'. [objectDestructuring28.ts:5:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring28.ts b/es2panda/test/compiler/ts/objectDestructuring28.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a5f8eee556f46dbeb8bd5fb89109bcde24f1ba60
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring28.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var e: void;
+var u: { a: number, b: string };
+var { a: { b: [c = u, d] = [1, true] } = { b: [2n] } } = { a: { k: 2, b: ["foo", 2n] } };
+c = e;
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring29-expected.txt b/es2panda/test/compiler/ts/objectDestructuring29-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ee9ecfe383ca19b379959a4cc14c1f952621c363
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring29-expected.txt
@@ -0,0 +1,177 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 3
+                },
+                "end": {
+                  "line": 3,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 2
+            },
+            "end": {
+              "line": 3,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 8
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Property 'a' does not exist on type 'string [objectDestructuring29.ts:3:3]
diff --git a/es2panda/test/compiler/ts/objectDestructuring29.ts b/es2panda/test/compiler/ts/objectDestructuring29.ts
new file mode 100644
index 0000000000000000000000000000000000000000..456b95e182c8297e0d3b5d6723073dc09c871e78
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring29.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+({a} = "foo")
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring3-expected.txt b/es2panda/test/compiler/ts/objectDestructuring3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a859ffbbb9116d97037006c2e6efe096cfb734e
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring3-expected.txt
@@ -0,0 +1,242 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 12
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 12
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 12
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 30
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 33
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 35
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 35
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 36
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 36
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'foo' does not exist in type '{ a?: number; b: any; }'. [objectDestructuring3.ts:1:27]
diff --git a/es2panda/test/compiler/ts/objectDestructuring3.ts b/es2panda/test/compiler/ts/objectDestructuring3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0fcd61b0fccba35fb0e9011d9a1e0c2be248aa01
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a = 5, b: foo } = { foo: 5 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring30-expected.txt b/es2panda/test/compiler/ts/objectDestructuring30-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21cd88b453420f979f29ca5e4b569e6e8de5a915
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring30-expected.txt
@@ -0,0 +1,224 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 3
+                },
+                "end": {
+                  "line": 3,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 2
+            },
+            "end": {
+              "line": 3,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 18
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 8
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectDestructuring30.ts:3:3]
diff --git a/es2panda/test/compiler/ts/objectDestructuring30.ts b/es2panda/test/compiler/ts/objectDestructuring30.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e8c291f0665912708d8ba3ff0e2bd90f9d1bead
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring30.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+({a} = {a : "foo"})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring31-expected.txt b/es2panda/test/compiler/ts/objectDestructuring31-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..13ff8e08c3f3941126b5fb72a46ec85fe88dc2db
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring31-expected.txt
@@ -0,0 +1,251 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 4
+                    }
+                  }
+                },
+                "right": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 12
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 12
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 3
+                },
+                "end": {
+                  "line": 3,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 2
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 18
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 22
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 17
+                },
+                "end": {
+                  "line": 3,
+                  "column": 22
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 16
+            },
+            "end": {
+              "line": 3,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectDestructuring31.ts:3:3]
diff --git a/es2panda/test/compiler/ts/objectDestructuring31.ts b/es2panda/test/compiler/ts/objectDestructuring31.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0506ed35205448641abef9e689ba5be71e175172
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring31.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+({a = "foo"} = {a : 3})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring32-expected.txt b/es2panda/test/compiler/ts/objectDestructuring32-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..40655b488fb9909e8546b9c099eedb55136f1715
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring32-expected.txt
@@ -0,0 +1,166 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 3
+                },
+                "end": {
+                  "line": 2,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 2
+            },
+            "end": {
+              "line": 2,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 10
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 8
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: No value exists in scope for the shorthand property 'a'. Either declare one or provide an initializer. [objectDestructuring32.ts:2:3]
diff --git a/es2panda/test/compiler/ts/objectDestructuring32.ts b/es2panda/test/compiler/ts/objectDestructuring32.ts
new file mode 100644
index 0000000000000000000000000000000000000000..29a038d680518a5ba2372fee082cd3958fa2914c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring32.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+({a} = {a : 3})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring33-expected.txt b/es2panda/test/compiler/ts/objectDestructuring33-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ef95a67e382a4c0212e55e900f79ac0b1caa0946
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring33-expected.txt
@@ -0,0 +1,270 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 3
+                },
+                "end": {
+                  "line": 3,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 2
+            },
+            "end": {
+              "line": 3,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 17
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 21
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 8
+            },
+            "end": {
+              "line": 3,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 1
+    }
+  }
+}
+TypeError: Duplicate identifier 'a'. [objectDestructuring33.ts:3:16]
diff --git a/es2panda/test/compiler/ts/objectDestructuring33.ts b/es2panda/test/compiler/ts/objectDestructuring33.ts
new file mode 100644
index 0000000000000000000000000000000000000000..da0ed59ec7c123c3962ebf12169023b2aafac5fa
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring33.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+({a} = {a : 3, a : 4})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring34-expected.txt b/es2panda/test/compiler/ts/objectDestructuring34-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dc8845ba0b6f0ff6cf761f2eb413bbb69fa65ad6
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring34-expected.txt
@@ -0,0 +1,236 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 3
+                },
+                "end": {
+                  "line": 4,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 2
+            },
+            "end": {
+              "line": 4,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 8
+            },
+            "end": {
+              "line": 4,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Property 'a' does not exist on type 'string [objectDestructuring34.ts:4:3]
diff --git a/es2panda/test/compiler/ts/objectDestructuring34.ts b/es2panda/test/compiler/ts/objectDestructuring34.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5e997310a7fd267929f98aed90991d93e1b69c1c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring34.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+var b: string;
+({a} = b)
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring35-expected.txt b/es2panda/test/compiler/ts/objectDestructuring35-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c3b02d32844c347620a8c090c700dfb3dafc8ab1
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring35-expected.txt
@@ -0,0 +1,283 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 3
+                },
+                "end": {
+                  "line": 4,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 2
+            },
+            "end": {
+              "line": 4,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 8
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectDestructuring35.ts:4:3]
diff --git a/es2panda/test/compiler/ts/objectDestructuring35.ts b/es2panda/test/compiler/ts/objectDestructuring35.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4a8d7059ec938f9a53e5a5f393a409f4ed92565a
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring35.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+var b: string;
+({a} = {a : b})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring36-expected.txt b/es2panda/test/compiler/ts/objectDestructuring36-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ecfeae29bdd41c58eec44eba0a39ef7687a21775
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring36-expected.txt
@@ -0,0 +1,387 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectPattern",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 9
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 10
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 3
+                },
+                "end": {
+                  "line": 5,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 2
+            },
+            "end": {
+              "line": 5,
+              "column": 11
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 16
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 24
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 15
+                },
+                "end": {
+                  "line": 5,
+                  "column": 24
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 14
+            },
+            "end": {
+              "line": 5,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Property 'c' does not exist on type 'string [objectDestructuring36.ts:5:8]
diff --git a/es2panda/test/compiler/ts/objectDestructuring36.ts b/es2panda/test/compiler/ts/objectDestructuring36.ts
new file mode 100644
index 0000000000000000000000000000000000000000..27df5fe665f77906f81c89bb1cf947b071768ca3
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring36.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a = {};
+var b: number;
+var c: string;
+({a : {c}} = {a : "foo"})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring37-expected.txt b/es2panda/test/compiler/ts/objectDestructuring37-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..158d14756027a5c61661f5fc9141947f6ee0778e
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring37-expected.txt
@@ -0,0 +1,435 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectPattern",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 9
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 10
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 3
+                },
+                "end": {
+                  "line": 5,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 2
+            },
+            "end": {
+              "line": 5,
+              "column": 11
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 16
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 22
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 15
+                },
+                "end": {
+                  "line": 5,
+                  "column": 22
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 14
+            },
+            "end": {
+              "line": 5,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'b' does not exist in type '{ c: string; }'. [objectDestructuring37.ts:5:20]
diff --git a/es2panda/test/compiler/ts/objectDestructuring37.ts b/es2panda/test/compiler/ts/objectDestructuring37.ts
new file mode 100644
index 0000000000000000000000000000000000000000..23889716fe288f694646aba1c7c224117b55c4af
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring37.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a = {};
+var b: number;
+var c: string;
+({a : {c}} = {a : {b}})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring38-expected.txt b/es2panda/test/compiler/ts/objectDestructuring38-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c47b53586e0d5a3f53a757c4da0d533ab0b43fd6
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring38-expected.txt
@@ -0,0 +1,435 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectPattern",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 9
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 10
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 3
+                },
+                "end": {
+                  "line": 5,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 2
+            },
+            "end": {
+              "line": 5,
+              "column": 11
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 16
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 25
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 26
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 15
+                },
+                "end": {
+                  "line": 5,
+                  "column": 26
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 14
+            },
+            "end": {
+              "line": 5,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 28
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 28
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [objectDestructuring38.ts:5:8]
diff --git a/es2panda/test/compiler/ts/objectDestructuring38.ts b/es2panda/test/compiler/ts/objectDestructuring38.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b45463d3f249fee719a5120cfc12868e747a5f62
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring38.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a = {};
+var b: number;
+var c: string;
+({a : {c}} = {a : {c : b}})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring39-expected.txt b/es2panda/test/compiler/ts/objectDestructuring39-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..34bb082ab7cdc891a3e0dfdc372da71d3ffe1b15
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring39-expected.txt
@@ -0,0 +1,328 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 3
+                },
+                "end": {
+                  "line": 4,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 2
+            },
+            "end": {
+              "line": 4,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 10
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 9
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 17
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 25
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 16
+                },
+                "end": {
+                  "line": 4,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 8
+            },
+            "end": {
+              "line": 4,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 27
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'. [objectDestructuring39.ts:4:16]
diff --git a/es2panda/test/compiler/ts/objectDestructuring39.ts b/es2panda/test/compiler/ts/objectDestructuring39.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1ffa0e513f8730d5bf07b7fe893ed75c1dfc2f7b
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring39.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+var b: string;
+({a} = {a : 5, b : "foo"})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring4-expected.txt b/es2panda/test/compiler/ts/objectDestructuring4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1f8cb0a86681020a47a1c5e8c7fce26c75ace5f9
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring4-expected.txt
@@ -0,0 +1,225 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "AssignmentPattern",
+                      "left": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 12
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 19
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 31
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 31
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 33
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 33
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 34
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 34
+    }
+  }
+}
+TypeError: Type 'number' must have a '[Symbol.iterator]()' method that returns an interator [objectDestructuring4.ts:1:10]
diff --git a/es2panda/test/compiler/ts/objectDestructuring4.ts b/es2panda/test/compiler/ts/objectDestructuring4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0b8a90747f02648907d72b3d67414eae9b7e0423
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: [b = 5, c] } = { a: 5 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring40-expected.txt b/es2panda/test/compiler/ts/objectDestructuring40-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..01e2c6d73310f038df024da90577f9c6c3a9d806
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring40-expected.txt
@@ -0,0 +1,329 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 4
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 3
+                },
+                "end": {
+                  "line": 4,
+                  "column": 4
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": true,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 7
+                  }
+                }
+              },
+              "value": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 7
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 6
+                },
+                "end": {
+                  "line": 4,
+                  "column": 7
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 2
+            },
+            "end": {
+              "line": 4,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 13
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 17
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 12
+                },
+                "end": {
+                  "line": 4,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 11
+            },
+            "end": {
+              "line": 4,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [objectDestructuring40.ts:4:6]
diff --git a/es2panda/test/compiler/ts/objectDestructuring40.ts b/es2panda/test/compiler/ts/objectDestructuring40.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a4d9c057602e14647a5e8aa13628c12df268a948
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring40.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: number;
+var b: string;
+({a, b} = {a : 5})
+
diff --git a/es2panda/test/compiler/ts/objectDestructuring41-expected.txt b/es2panda/test/compiler/ts/objectDestructuring41-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..015ad7fc4b9fa664fedce57616b372d64209f4c0
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring41-expected.txt
@@ -0,0 +1,601 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 9
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "ObjectPattern",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 4
+                  }
+                }
+              },
+              "value": {
+                "type": "AssignmentPattern",
+                "left": {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 7
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 8
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 7
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 8
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 7
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 8
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 11
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 12
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 25
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 3
+                },
+                "end": {
+                  "line": 5,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 2
+            },
+            "end": {
+              "line": 5,
+              "column": 26
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 31
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 36
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 10,
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 40
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 43
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 50
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 50
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 51
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 30
+                },
+                "end": {
+                  "line": 5,
+                  "column": 51
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 29
+            },
+            "end": {
+              "line": 5,
+              "column": 52
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 53
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 54
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 54
+    }
+  }
+}
+TypeError: Initializer provides no value for this binding element and the binding element has no default value [objectDestructuring41.ts:5:7]
diff --git a/es2panda/test/compiler/ts/objectDestructuring41.ts b/es2panda/test/compiler/ts/objectDestructuring41.ts
new file mode 100644
index 0000000000000000000000000000000000000000..32a5cdfc47d62cc76ba9657e9b59cf2eda5551a8
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring41.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var b: string;
+var c = {};
+
+({c: {b, a} = {a: "baz"}} = {c : {a: 10, b: "bar"}});
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring5-expected.txt b/es2panda/test/compiler/ts/objectDestructuring5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a63cbba62b755469b09d74c933c737268f67741c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring5-expected.txt
@@ -0,0 +1,225 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "AssignmentPattern",
+                      "left": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 12
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 23
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 24
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 39
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 39
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 29
+              },
+              "end": {
+                "line": 1,
+                "column": 41
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 41
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 42
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 42
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'b' does not exist in type '{ a: [string?, any]; }'. [objectDestructuring5.ts:1:31]
diff --git a/es2panda/test/compiler/ts/objectDestructuring5.ts b/es2panda/test/compiler/ts/objectDestructuring5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0ae713134501387295fadcfe0521990b24b87be
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: [b = "bar", c] } = { b: "foo" };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring6-expected.txt b/es2panda/test/compiler/ts/objectDestructuring6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..85232e6d523c93be13a90f275f07203e5554a392
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring6-expected.txt
@@ -0,0 +1,410 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 29
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 34
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 38
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 40
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 40
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 18
+              },
+              "end": {
+                "line": 1,
+                "column": 42
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 42
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 43
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 10
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 17
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 20
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 27
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 19
+                },
+                "end": {
+                  "line": 2,
+                  "column": 27
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 7
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 30
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectDestructuring6.ts:2:9]
diff --git a/es2panda/test/compiler/ts/objectDestructuring6.ts b/es2panda/test/compiler/ts/objectDestructuring6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4ac2f72fc90d4aff91a7fa2ab9bcecc3aa7c1163
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: foo } = { a: { a: 1, b: true } };
+foo = { a: "foo", b: false };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring7-expected.txt b/es2panda/test/compiler/ts/objectDestructuring7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..68ce229dcc0a148a8ae48693065e5f9dd04ebfe5
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring7-expected.txt
@@ -0,0 +1,484 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 13
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 14
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "NumberLiteral",
+                          "value": 5,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 16
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 17
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 17
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 20
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 22
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 26
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 30
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 36
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 40
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 40
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 33
+              },
+              "end": {
+                "line": 1,
+                "column": 42
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 42
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 43
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 8
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 11
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 7
+                },
+                "end": {
+                  "line": 2,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 14
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 21
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 21
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 24
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 6,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 27
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 23
+                },
+                "end": {
+                  "line": 2,
+                  "column": 27
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 29
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 30
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 30
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'c' does not exist in type '{ a: number; b: boolean; } | bigint' [objectDestructuring7.ts:2:23]
diff --git a/es2panda/test/compiler/ts/objectDestructuring7.ts b/es2panda/test/compiler/ts/objectDestructuring7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ed4a4d4798ad59bc7cfe6c1c5aee821f59d52776
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring7.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a = { a: 5, b: true } } = { a: 3n };
+a = { a: 1, b: false, c: 6 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring8-expected.txt b/es2panda/test/compiler/ts/objectDestructuring8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d0f5241d622596638282231f473ebfbfe0ffdbdb
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring8-expected.txt
@@ -0,0 +1,549 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "AssignmentPattern",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "a",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 16
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 21
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 21
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 21
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 24
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 32
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "NumberLiteral",
+                          "value": 1,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 34
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 35
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 37
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 38
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 44
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 44
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 46
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 47
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "ObjectExpression",
+                          "properties": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 49
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 51
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 51
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 53
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 53
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 53
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 55
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 65
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 66
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "BigIntLiteral",
+                        "value": "",
+                        "bigint": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 68
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 70
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 65
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 70
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 72
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 73
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 75
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 80
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 72
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 80
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 63
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 82
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 60
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 82
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 58
+              },
+              "end": {
+                "line": 1,
+                "column": 84
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 84
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 84
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 84
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'c' does not exist in type '{ a?: string; b: any; }'. [objectDestructuring8.ts:1:46]
diff --git a/es2panda/test/compiler/ts/objectDestructuring8.ts b/es2panda/test/compiler/ts/objectDestructuring8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9f3a5d485d73225b7bcb3fe804d4381004d02e9b
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring8.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: { a = "bar", b } = { a: 1, b: true, c: {} } } = { a: { a: 5n, b: "foo" } }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectDestructuring9-expected.txt b/es2panda/test/compiler/ts/objectDestructuring9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c0d3eaba09bb3f3afdf523d3ecf4e904d9c63916
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring9-expected.txt
@@ -0,0 +1,391 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 13
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 16
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "NumberLiteral",
+                          "value": 1,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 27
+                          }
+                        }
+                      },
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 32
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 36
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 38
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 38
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 40
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 43
+              },
+              "end": {
+                "line": 1,
+                "column": 45
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 45
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 8
+    }
+  }
+}
+TypeError: Type '{ }' is not assignable to type 'number'. [objectDestructuring9.ts:2:1]
diff --git a/es2panda/test/compiler/ts/objectDestructuring9.ts b/es2panda/test/compiler/ts/objectDestructuring9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..30f6821ecd907b748843c779edc0cbd487e832c8
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectDestructuring9.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var { a: { a, b } = { a: 1, b: true } } = {}
+a = {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fc4f5b1a0b4485c45fe128e9c8d58972fe1de828
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability-expected.txt
@@ -0,0 +1,8934 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj1",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 11
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj2",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 14
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 23
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 33
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 35
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 35
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 41
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 43
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 49
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 40
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 50
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 51
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 54
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 60
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 61
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 62
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 63
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 65
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 71
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 62
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 73
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 73
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 11
+                },
+                "end": {
+                  "line": 2,
+                  "column": 73
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 78
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 79
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 81
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 82
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 78
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 82
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 85
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 87
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 92
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 84
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 92
+                  }
+                }
+              },
+              {
+                "type": "SpreadElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "obj1",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 97
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 101
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 94
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 101
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 76
+              },
+              "end": {
+                "line": 2,
+                "column": 103
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 103
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 104
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 18
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 10
+                },
+                "end": {
+                  "line": 3,
+                  "column": 18
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 21
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 28
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 20
+                },
+                "end": {
+                  "line": 3,
+                  "column": 28
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 31
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 38
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 30
+                },
+                "end": {
+                  "line": 3,
+                  "column": 38
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 8
+            },
+            "end": {
+              "line": 3,
+              "column": 40
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 40
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 41
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj3",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 11
+                },
+                "end": {
+                  "line": 5,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 16
+              },
+              "end": {
+                "line": 5,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj4",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeQuery",
+                    "exprName": {
+                      "type": "Identifier",
+                      "name": "obj3",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 28
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 6,
+                              "column": 35
+                            },
+                            "end": {
+                              "line": 6,
+                              "column": 36
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 6,
+                              "column": 38
+                            },
+                            "end": {
+                              "line": 6,
+                              "column": 44
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 45
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": true,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 6,
+                              "column": 46
+                            },
+                            "end": {
+                              "line": 6,
+                              "column": 47
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 6,
+                              "column": 50
+                            },
+                            "end": {
+                              "line": 6,
+                              "column": 56
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 58
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 58
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 60
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 11
+                },
+                "end": {
+                  "line": 6,
+                  "column": 60
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 65
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 66
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 68
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 70
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 65
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 70
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 72
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 73
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 77
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 78
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 80
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 81
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 77
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 81
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 75
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 83
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 83
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 63
+              },
+              "end": {
+                "line": 6,
+                "column": 85
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 85
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 86
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 10
+                },
+                "end": {
+                  "line": 7,
+                  "column": 15
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 18
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 23
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 26
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 26
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 36
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 36
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 38
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 17
+                },
+                "end": {
+                  "line": 7,
+                  "column": 38
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 8
+            },
+            "end": {
+              "line": 7,
+              "column": 40
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 40
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 41
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "ObjectExpression",
+                "properties": [],
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 10
+                },
+                "end": {
+                  "line": 8,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 8
+            },
+            "end": {
+              "line": 8,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj5",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 28
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 32
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 38
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 40
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 47
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 48
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 50
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 57
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 47
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 59
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 59
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 61
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 11
+                },
+                "end": {
+                  "line": 10,
+                  "column": 61
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 66
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 67
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 71
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 72
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 74
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 75
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 10,
+                          "column": 71
+                        },
+                        "end": {
+                          "line": 10,
+                          "column": 75
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 77
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 78
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 80
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 85
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 10,
+                          "column": 77
+                        },
+                        "end": {
+                          "line": 10,
+                          "column": 85
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 69
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 87
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 66
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 87
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 89
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 90
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 94
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 95
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 97
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 101
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 10,
+                          "column": 94
+                        },
+                        "end": {
+                          "line": 10,
+                          "column": 101
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 92
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 103
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 89
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 103
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 64
+              },
+              "end": {
+                "line": 10,
+                "column": 105
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 105
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 106
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj6",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 11,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 11,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 11,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 11,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 27
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 45
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "params": [],
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 58
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 60
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 11
+                },
+                "end": {
+                  "line": 11,
+                  "column": 60
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 5
+            },
+            "end": {
+              "line": 11,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 1
+            },
+            "end": {
+              "line": 12,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 12,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 24
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 12,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 43
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 35
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [
+                      {
+                        "type": "ReturnStatement",
+                        "argument": {
+                          "type": "NumberLiteral",
+                          "value": 12,
+                          "loc": {
+                            "start": {
+                              "line": 12,
+                              "column": 62
+                            },
+                            "end": {
+                              "line": 12,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 12,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 65
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 67
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 67
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 67
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 10
+                },
+                "end": {
+                  "line": 12,
+                  "column": 67
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 69
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 70
+                  }
+                }
+              },
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [
+                      {
+                        "type": "ReturnStatement",
+                        "argument": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 12,
+                              "column": 93
+                            },
+                            "end": {
+                              "line": 12,
+                              "column": 97
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 12,
+                            "column": 86
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 97
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 84
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 99
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 72
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 99
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 99
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 69
+                },
+                "end": {
+                  "line": 12,
+                  "column": 99
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 8
+            },
+            "end": {
+              "line": 12,
+              "column": 101
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 1
+          },
+          "end": {
+            "line": 12,
+            "column": 101
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 102
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj7",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 13
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 34
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 43
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 44
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 45
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 46
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 54
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 56
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 56
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 61
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 64
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 71
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 61
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 72
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 73
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 74
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 76
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 82
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 73
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 83
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 84
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 85
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 87
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 93
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 84
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 95
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 59
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 95
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 11
+                },
+                "end": {
+                  "line": 14,
+                  "column": 95
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 96
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 1
+            },
+            "end": {
+              "line": 15,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 8
+            },
+            "end": {
+              "line": 15,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 15,
+            "column": 1
+          },
+          "end": {
+            "line": 15,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 1
+            },
+            "end": {
+              "line": 16,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 10
+                },
+                "end": {
+                  "line": 16,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 8
+            },
+            "end": {
+              "line": 16,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 1
+          },
+          "end": {
+            "line": 16,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 18
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 10
+                },
+                "end": {
+                  "line": 17,
+                  "column": 18
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 21
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 24
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 20
+                },
+                "end": {
+                  "line": 17,
+                  "column": 24
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 8
+            },
+            "end": {
+              "line": 17,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 17
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 10
+                },
+                "end": {
+                  "line": 18,
+                  "column": 17
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 20
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 27
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 19
+                },
+                "end": {
+                  "line": 18,
+                  "column": 27
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 30
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 33
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 29
+                },
+                "end": {
+                  "line": 18,
+                  "column": 33
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 8
+            },
+            "end": {
+              "line": 18,
+              "column": 35
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 35
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj8",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "SpreadElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "obj6",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 12
+              },
+              "end": {
+                "line": 20,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 5
+            },
+            "end": {
+              "line": 20,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj8",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "obj6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 8
+            },
+            "end": {
+              "line": 21,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj8",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 11
+                  }
+                }
+              },
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 22,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 24
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 22,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 43
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 35
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [
+                      {
+                        "type": "ReturnStatement",
+                        "argument": {
+                          "type": "NumberLiteral",
+                          "value": 12,
+                          "loc": {
+                            "start": {
+                              "line": 22,
+                              "column": 62
+                            },
+                            "end": {
+                              "line": 22,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 22,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 65
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 67
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 67
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 67
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 10
+                },
+                "end": {
+                  "line": 22,
+                  "column": 67
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 69
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 70
+                  }
+                }
+              },
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [
+                      {
+                        "type": "ReturnStatement",
+                        "argument": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 22,
+                              "column": 93
+                            },
+                            "end": {
+                              "line": 22,
+                              "column": 97
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 22,
+                            "column": 86
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 97
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 84
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 99
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 72
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 99
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 99
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 69
+                },
+                "end": {
+                  "line": 22,
+                  "column": 99
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 8
+            },
+            "end": {
+              "line": 22,
+              "column": 101
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 101
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 102
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSLiteralType",
+              "literal": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 8
+                },
+                "end": {
+                  "line": 24,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 5
+              },
+              "end": {
+                "line": 24,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 5
+            },
+            "end": {
+              "line": 24,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSLiteralType",
+              "literal": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj9",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": true,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": true,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 11
+                },
+                "end": {
+                  "line": 26,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 26,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 45
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 48
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 48
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 50
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 55
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 57
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 62
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 50
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 62
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 42
+              },
+              "end": {
+                "line": 26,
+                "column": 64
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 5
+            },
+            "end": {
+              "line": 26,
+              "column": 64
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 65
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 8
+                },
+                "end": {
+                  "line": 28,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 5
+            },
+            "end": {
+              "line": 28,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 8
+                },
+                "end": {
+                  "line": 29,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 29,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj10",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "x",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "readonly": false,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 34
+                    }
+                  }
+                },
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "y",
+                    "typeAnnotation": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 45
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "readonly": false,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 56
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 12
+                },
+                "end": {
+                  "line": 30,
+                  "column": 56
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 5
+              },
+              "end": {
+                "line": 30,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": true,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 62
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 63
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 66
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 67
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 61
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 67
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": true,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 70
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 71
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 74
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 75
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 69
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 75
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 59
+              },
+              "end": {
+                "line": 30,
+                "column": 77
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 5
+            },
+            "end": {
+              "line": 30,
+              "column": 77
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 78
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj11",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 5
+              },
+              "end": {
+                "line": 32,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 20
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "NumberLiteral",
+                            "value": 5,
+                            "loc": {
+                              "start": {
+                                "line": 32,
+                                "column": 32
+                              },
+                              "end": {
+                                "line": 32,
+                                "column": 33
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 32,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 32,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 36
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 36
+                    }
+                  }
+                },
+                "kind": "get",
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 36
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 47
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 32,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 32,
+                            "column": 49
+                          }
+                        }
+                      }
+                    ],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 54
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 54
+                    }
+                  }
+                },
+                "kind": "set",
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 54
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 13
+              },
+              "end": {
+                "line": 32,
+                "column": 56
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 5
+            },
+            "end": {
+              "line": 32,
+              "column": 56
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 57
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 1
+            },
+            "end": {
+              "line": 33,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "obj11",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 8
+            },
+            "end": {
+              "line": 33,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 1
+          },
+          "end": {
+            "line": 33,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj12",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 37
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 51
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 12
+                },
+                "end": {
+                  "line": 35,
+                  "column": 51
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 5
+              },
+              "end": {
+                "line": 35,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 5
+            },
+            "end": {
+              "line": 35,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 52
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 1
+            },
+            "end": {
+              "line": 36,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 9
+            },
+            "end": {
+              "line": 36,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 1
+          },
+          "end": {
+            "line": 36,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 1
+            },
+            "end": {
+              "line": 37,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 11
+                },
+                "end": {
+                  "line": 37,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 9
+            },
+            "end": {
+              "line": 37,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 1
+          },
+          "end": {
+            "line": 37,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 1
+            },
+            "end": {
+              "line": 38,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 38,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 38,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 38,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 38,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 11
+                },
+                "end": {
+                  "line": 38,
+                  "column": 15
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 38,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 38,
+                    "column": 18
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 38,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 38,
+                    "column": 25
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 17
+                },
+                "end": {
+                  "line": 38,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 9
+            },
+            "end": {
+              "line": 38,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 1
+          },
+          "end": {
+            "line": 38,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 39,
+              "column": 1
+            },
+            "end": {
+              "line": 39,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 19
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 11
+                },
+                "end": {
+                  "line": 39,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 39,
+              "column": 9
+            },
+            "end": {
+              "line": 39,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 39,
+            "column": 1
+          },
+          "end": {
+            "line": 39,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 39,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 1
+            },
+            "end": {
+              "line": 40,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 19
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 11
+                },
+                "end": {
+                  "line": 40,
+                  "column": 19
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 22
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 25
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 21
+                },
+                "end": {
+                  "line": 40,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 9
+            },
+            "end": {
+              "line": 40,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 40,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 1
+            },
+            "end": {
+              "line": 41,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 11
+                },
+                "end": {
+                  "line": 41,
+                  "column": 15
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 18
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 24
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 17
+                },
+                "end": {
+                  "line": 41,
+                  "column": 24
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 9
+            },
+            "end": {
+              "line": 41,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 1
+          },
+          "end": {
+            "line": 41,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 1
+            },
+            "end": {
+              "line": 42,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 19
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 11
+                },
+                "end": {
+                  "line": 42,
+                  "column": 19
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 22
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 42,
+                    "column": 29
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 21
+                },
+                "end": {
+                  "line": 42,
+                  "column": 29
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 9
+            },
+            "end": {
+              "line": 42,
+              "column": 31
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 1
+          },
+          "end": {
+            "line": 42,
+            "column": 31
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 42,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 5
+                },
+                "end": {
+                  "line": 45,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 8
+                },
+                "end": {
+                  "line": 45,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 5
+                },
+                "end": {
+                  "line": 46,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 8
+                },
+                "end": {
+                  "line": 46,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 46,
+                "column": 5
+              },
+              "end": {
+                "line": 46,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 5
+                },
+                "end": {
+                  "line": 47,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 8
+                },
+                "end": {
+                  "line": 47,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 5
+              },
+              "end": {
+                "line": 47,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 44,
+            "column": 22
+          },
+          "end": {
+            "line": 48,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 44,
+            "column": 11
+          },
+          "end": {
+            "line": 44,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 44,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 5
+                },
+                "end": {
+                  "line": 51,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 8
+                },
+                "end": {
+                  "line": 51,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 51,
+                "column": 5
+              },
+              "end": {
+                "line": 52,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 41
+          },
+          "end": {
+            "line": 52,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 11
+          },
+          "end": {
+            "line": 50,
+            "column": 21
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "interface1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 30
+              },
+              "end": {
+                "line": 50,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 41
+            },
+            "end": {
+              "line": 50,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj13",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 12
+                },
+                "end": {
+                  "line": 54,
+                  "column": 22
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 5
+              },
+              "end": {
+                "line": 54,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 28
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 31
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 31
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 34
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 36
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 41
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 41
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 44
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 47
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 47
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 50
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 52
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 53
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 53
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 25
+              },
+              "end": {
+                "line": 54,
+                "column": 55
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 5
+            },
+            "end": {
+              "line": 54,
+              "column": 55
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 54,
+          "column": 56
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj14",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 55,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 55,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSArrayType",
+                            "elementType": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 55,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 55,
+                                  "column": 23
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 55,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 55,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSTupleType",
+                            "elementTypes": [
+                              {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 55,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 55,
+                                    "column": 36
+                                  }
+                                }
+                              },
+                              {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 55,
+                                    "column": 37
+                                  },
+                                  "end": {
+                                    "line": 55,
+                                    "column": 44
+                                  }
+                                }
+                              },
+                              {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 55,
+                                    "column": 45
+                                  },
+                                  "end": {
+                                    "line": 55,
+                                    "column": 52
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 55,
+                                "column": 28
+                              },
+                              "end": {
+                                "line": 55,
+                                "column": 52
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 55,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 55,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 55,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 55,
+                          "column": 53
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSMethodSignature",
+                      "computed": false,
+                      "optional": true,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 55,
+                            "column": 54
+                          },
+                          "end": {
+                            "line": 55,
+                            "column": 55
+                          }
+                        }
+                      },
+                      "params": [
+                        {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "TSArrayType",
+                            "elementType": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 55,
+                                  "column": 60
+                                },
+                                "end": {
+                                  "line": 55,
+                                  "column": 66
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 55,
+                                "column": 60
+                              },
+                              "end": {
+                                "line": 55,
+                                "column": 68
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 55,
+                              "column": 57
+                            },
+                            "end": {
+                              "line": 55,
+                              "column": 58
+                            }
+                          }
+                        }
+                      ],
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 55,
+                              "column": 71
+                            },
+                            "end": {
+                              "line": 55,
+                              "column": 77
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 55,
+                            "column": 71
+                          },
+                          "end": {
+                            "line": 55,
+                            "column": 79
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 55,
+                          "column": 54
+                        },
+                        "end": {
+                          "line": 55,
+                          "column": 81
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 55,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 55,
+                      "column": 81
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "interface2",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 55,
+                        "column": 84
+                      },
+                      "end": {
+                        "line": 55,
+                        "column": 94
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 55,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 55,
+                      "column": 94
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 12
+                },
+                "end": {
+                  "line": 55,
+                  "column": 94
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 55,
+                "column": 5
+              },
+              "end": {
+                "line": 55,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 55,
+              "column": 5
+            },
+            "end": {
+              "line": 55,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 55,
+          "column": 1
+        },
+        "end": {
+          "line": 55,
+          "column": 95
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 1
+            },
+            "end": {
+              "line": 56,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "obj13",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 9
+            },
+            "end": {
+              "line": 56,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 56,
+            "column": 1
+          },
+          "end": {
+            "line": 56,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 56,
+          "column": 1
+        },
+        "end": {
+          "line": 56,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 1
+            },
+            "end": {
+              "line": 57,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 11
+                },
+                "end": {
+                  "line": 57,
+                  "column": 15
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 18
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 25
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 17
+                },
+                "end": {
+                  "line": 57,
+                  "column": 25
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 28
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 31
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 27
+                },
+                "end": {
+                  "line": 57,
+                  "column": 31
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 34
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 37
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 33
+                },
+                "end": {
+                  "line": 57,
+                  "column": 37
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 9
+            },
+            "end": {
+              "line": 57,
+              "column": 39
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 57,
+            "column": 1
+          },
+          "end": {
+            "line": 57,
+            "column": 39
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 57,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 1
+            },
+            "end": {
+              "line": 58,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 58,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 58,
+                        "column": 16
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 58,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 58,
+                        "column": 19
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 58,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 58,
+                        "column": 22
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 23
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 11
+                },
+                "end": {
+                  "line": 58,
+                  "column": 23
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 9
+            },
+            "end": {
+              "line": 58,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 58,
+            "column": 1
+          },
+          "end": {
+            "line": 58,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 58,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 1
+            },
+            "end": {
+              "line": 59,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 59,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 59,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 59,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 59,
+                        "column": 20
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 59,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 59,
+                        "column": 27
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 59,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 59,
+                        "column": 34
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 59,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 59,
+                    "column": 35
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 11
+                },
+                "end": {
+                  "line": 59,
+                  "column": 35
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 9
+            },
+            "end": {
+              "line": 59,
+              "column": 37
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 59,
+            "column": 1
+          },
+          "end": {
+            "line": 59,
+            "column": 37
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 59,
+          "column": 1
+        },
+        "end": {
+          "line": 59,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 1
+            },
+            "end": {
+              "line": 60,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 60,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 60,
+                        "column": 20
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 60,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 60,
+                        "column": 27
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 60,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 60,
+                        "column": 34
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 35
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 11
+                },
+                "end": {
+                  "line": 60,
+                  "column": 35
+                }
+              }
+            },
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 38
+                  }
+                }
+              },
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSParenthesizedType",
+                        "typeAnnotation": {
+                          "type": "TSArrayType",
+                          "elementType": {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 60,
+                                "column": 54
+                              },
+                              "end": {
+                                "line": 60,
+                                "column": 60
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 60,
+                              "column": 54
+                            },
+                            "end": {
+                              "line": 60,
+                              "column": 62
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 60,
+                            "column": 53
+                          },
+                          "end": {
+                            "line": 60,
+                            "column": 63
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 60,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 60,
+                          "column": 51
+                        }
+                      }
+                    }
+                  ],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [
+                      {
+                        "type": "ReturnStatement",
+                        "argument": {
+                          "type": "ArrayExpression",
+                          "elements": [
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 60,
+                                  "column": 75
+                                },
+                                "end": {
+                                  "line": 60,
+                                  "column": 80
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 60,
+                                  "column": 82
+                                },
+                                "end": {
+                                  "line": 60,
+                                  "column": 87
+                                }
+                              }
+                            },
+                            {
+                              "type": "StringLiteral",
+                              "value": "",
+                              "loc": {
+                                "start": {
+                                  "line": 60,
+                                  "column": 89
+                                },
+                                "end": {
+                                  "line": 60,
+                                  "column": 94
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 60,
+                              "column": 74
+                            },
+                            "end": {
+                              "line": 60,
+                              "column": 95
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 60,
+                            "column": 67
+                          },
+                          "end": {
+                            "line": 60,
+                            "column": 95
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 60,
+                        "column": 65
+                      },
+                      "end": {
+                        "line": 60,
+                        "column": 97
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 60,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 60,
+                      "column": 97
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 97
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 37
+                },
+                "end": {
+                  "line": 60,
+                  "column": 97
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 9
+            },
+            "end": {
+              "line": 60,
+              "column": 99
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 60,
+            "column": 1
+          },
+          "end": {
+            "line": 60,
+            "column": 99
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 60,
+          "column": 1
+        },
+        "end": {
+          "line": 60,
+          "column": 100
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 5
+                },
+                "end": {
+                  "line": 63,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 8
+                },
+                "end": {
+                  "line": 63,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 63,
+                "column": 5
+              },
+              "end": {
+                "line": 64,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 62,
+            "column": 22
+          },
+          "end": {
+            "line": 64,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 62,
+            "column": 11
+          },
+          "end": {
+            "line": 62,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 62,
+          "column": 1
+        },
+        "end": {
+          "line": 64,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 5
+                },
+                "end": {
+                  "line": 67,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 8
+                },
+                "end": {
+                  "line": 67,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 67,
+                "column": 5
+              },
+              "end": {
+                "line": 68,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 66,
+            "column": 41
+          },
+          "end": {
+            "line": 68,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 66,
+            "column": 11
+          },
+          "end": {
+            "line": 66,
+            "column": 21
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "interface3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 66,
+                "column": 30
+              },
+              "end": {
+                "line": 66,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 66,
+              "column": 41
+            },
+            "end": {
+              "line": 66,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 66,
+          "column": 1
+        },
+        "end": {
+          "line": 68,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 71,
+                  "column": 5
+                },
+                "end": {
+                  "line": 71,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 71,
+                  "column": 8
+                },
+                "end": {
+                  "line": 71,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 71,
+                "column": 5
+              },
+              "end": {
+                "line": 72,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 70,
+            "column": 41
+          },
+          "end": {
+            "line": 72,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface5",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 70,
+            "column": 11
+          },
+          "end": {
+            "line": 70,
+            "column": 21
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "interface3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 70,
+                "column": 30
+              },
+              "end": {
+                "line": 70,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 70,
+              "column": 41
+            },
+            "end": {
+              "line": 70,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 70,
+          "column": 1
+        },
+        "end": {
+          "line": 72,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 75,
+                  "column": 5
+                },
+                "end": {
+                  "line": 75,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 75,
+                  "column": 8
+                },
+                "end": {
+                  "line": 75,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 75,
+                "column": 5
+              },
+              "end": {
+                "line": 76,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 74,
+            "column": 41
+          },
+          "end": {
+            "line": 76,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface6",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 74,
+            "column": 11
+          },
+          "end": {
+            "line": 74,
+            "column": 21
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "interface3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 74,
+                "column": 30
+              },
+              "end": {
+                "line": 74,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 74,
+              "column": 41
+            },
+            "end": {
+              "line": 74,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 74,
+          "column": 1
+        },
+        "end": {
+          "line": 76,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj15",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "interface4",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "interface5",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 35
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "interface6",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 48
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 48
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 12
+                },
+                "end": {
+                  "line": 78,
+                  "column": 48
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 78,
+                "column": 5
+              },
+              "end": {
+                "line": 78,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 78,
+              "column": 5
+            },
+            "end": {
+              "line": 78,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 78,
+          "column": 1
+        },
+        "end": {
+          "line": 78,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj15",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 79,
+              "column": 1
+            },
+            "end": {
+              "line": 79,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 79,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 79,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 79,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 79,
+                    "column": 15
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 79,
+                  "column": 11
+                },
+                "end": {
+                  "line": 79,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 79,
+              "column": 9
+            },
+            "end": {
+              "line": 79,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 79,
+            "column": 1
+          },
+          "end": {
+            "line": 79,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 79,
+          "column": 1
+        },
+        "end": {
+          "line": 79,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj15",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 80,
+              "column": 1
+            },
+            "end": {
+              "line": 80,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 80,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 80,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 80,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 80,
+                    "column": 19
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 80,
+                  "column": 11
+                },
+                "end": {
+                  "line": 80,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 80,
+              "column": 9
+            },
+            "end": {
+              "line": 80,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 80,
+            "column": 1
+          },
+          "end": {
+            "line": 80,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 80,
+          "column": 1
+        },
+        "end": {
+          "line": 80,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "obj15",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 81,
+              "column": 1
+            },
+            "end": {
+              "line": 81,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "ObjectExpression",
+          "properties": [
+            {
+              "type": "Property",
+              "method": false,
+              "shorthand": false,
+              "computed": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 81,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 81,
+                    "column": 12
+                  }
+                }
+              },
+              "value": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 81,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 81,
+                    "column": 18
+                  }
+                }
+              },
+              "kind": "init",
+              "loc": {
+                "start": {
+                  "line": 81,
+                  "column": 11
+                },
+                "end": {
+                  "line": 81,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 81,
+              "column": 9
+            },
+            "end": {
+              "line": 81,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 81,
+            "column": 1
+          },
+          "end": {
+            "line": 81,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 81,
+          "column": 1
+        },
+        "end": {
+          "line": 81,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 81,
+      "column": 21
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability.ts b/es2panda/test/compiler/ts/objectLiteralAssignability.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c51da9a377a9e0521bd3bda6ab7a9f4c5ecd239a
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability.ts
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var obj1: { c: number };
+var obj2: { a: number, b: string } | { a: string, b: string, c: string } = { a: 5, b: "foo", ...obj1 };
+obj2 = { a: "foo", b: "bar", c: "baz" };
+
+var obj3: {} = {};
+var obj4: { a: typeof obj3, b?: { a: number, b?: string } } = { a: {}, b: { a: 5 } };
+obj4 = { a: {}, b: { a: 5, b: "foo" } };
+obj4 = { a: {} };
+
+var obj5: { a: { a: number, b: string }, b: { a: boolean } } = { a: { a: 5, b: "foo" }, b: { a: true } };
+var obj6: { a(a: number, b: string): number, b(): boolean };
+obj6 = { a: function (a: number, b: string): number { return 12; }, b: function () { return true } };
+
+var obj7: {} | { a: number } | { a: string, b: number } | { a: boolean, b: string, c: number };
+obj7 = {};
+obj7 = { a: 5 };
+obj7 = { a: "foo", b: 5 };
+obj7 = { a: true, b: "foo", c: 5 };
+
+var obj8 = { ...obj6 };
+obj8 = obj6;
+obj8 = { a: function (a: number, b: string): number { return 12; }, b: function () { return true } };
+
+var a: 5;
+var b: "foo";
+var obj9: { [a]: number, [b]: string } = { 5: 5, "foo": "foo" };
+
+var c: number;
+var d: string;
+var obj10: { [x: number]: number, [y: string]: number } = { [c]: 1, [d]: 2 };
+
+var obj11 = { get 5() { return 5; }, set "foo"(a) { } };
+obj9 = obj11;
+
+var obj12: { a?: number, b?: string, c?: boolean };
+obj12 = {};
+obj12 = { a: 5 };
+obj12 = { a: 5, b: "foo" };
+obj12 = { b: "foo" };
+obj12 = { b: "foo", a: 5 };
+obj12 = { a: 5, c: true };
+obj12 = { c: false, b: "bar" };
+
+interface interface1 {
+    a: number,
+    b: string,
+    c: number,
+}
+
+interface interface2 extends interface1 {
+    d: number
+}
+
+var obj13: interface2 = { a: 5, b: "foo", c: 5, d: 5 };
+var obj14: { a: number[] | [string, string, string], b?(a: number[]): string[] } | interface2;
+obj14 = obj13;
+obj14 = { a: 5, b: "foo", c: 5, d: 5 };
+obj14 = { a: [1, 2, 3] };
+obj14 = { a: ["foo", "bar", "baz"] };
+obj14 = { a: ["foo", "bar", "baz"], b: function (a: (number[])) { return ["foo", "bar", "baz"] } };
+
+interface interface3 {
+    a: number | string | boolean
+}
+
+interface interface4 extends interface3 {
+    a: number
+}
+
+interface interface5 extends interface3 {
+    a: string
+}
+
+interface interface6 extends interface3 {
+    a: boolean
+}
+
+var obj15: interface4 | interface5 | interface6;
+obj15 = { a: 5 };
+obj15 = { a: "foo" };
+obj15 = { a: true };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability1-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..35dc3c8ef46714bc4793c3f7777722b355ae0fe6
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability1-expected.txt
@@ -0,0 +1,270 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 45
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 48
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 50
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 55
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 35
+              },
+              "end": {
+                "line": 1,
+                "column": 57
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 57
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 58
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 58
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectLiteralAssignability1.ts:1:37]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability1.ts b/es2panda/test/compiler/ts/objectLiteralAssignability1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..67af33a345f1c94e805d19cd1f0ab3229effa08c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number, b: string } = { a: "foo", b: "bar" };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability10-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4d0bbec189f2e08168f6485bcf23582a420a3270
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability10-expected.txt
@@ -0,0 +1,363 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 50
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 49
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 53
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 56
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 6,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 58
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 55
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 61
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 42
+              },
+              "end": {
+                "line": 1,
+                "column": 63
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 63
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 64
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 64
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [objectLiteralAssignability10.ts:1:55]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability10.ts b/es2panda/test/compiler/ts/objectLiteralAssignability10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9aade83fd5d988e7b8d34fde519800ef6fa5f771
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability10.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: { a: number, b: string } } = { a: { a: 5, b: 6 } };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability11-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..40ad6b64cb47aa60b5776ec364fb6dd6650d8ce8
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability11-expected.txt
@@ -0,0 +1,460 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 16
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 26
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 35
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 29
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 37
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 26
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 41
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 51
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 52
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 54
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 60
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 54
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 62
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 51
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 63
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 64
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 65
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 73
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 75
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 75
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 77
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 77
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 77
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 82
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 83
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 85
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 86
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 82
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 86
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 80
+              },
+              "end": {
+                "line": 1,
+                "column": 88
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 88
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 88
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 88
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type '{ a: number[]; b: number; } | { a: number; b: string[]; }'. [objectLiteralAssignability11.ts:1:82]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability11.ts b/es2panda/test/compiler/ts/objectLiteralAssignability11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1bfaa0d113d4af13c8ce282d19b5db8a7306725b
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability11.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: { a: number, b: string[] } } | { a: { a: number[], b: number } } = { a: 5 }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability12-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..73907ad142fce2921edb523a28bdb8649181c07a
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability12-expected.txt
@@ -0,0 +1,564 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 16
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 26
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 35
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 29
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 37
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 26
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 41
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 51
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 52
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 54
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 60
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 54
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 62
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 51
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 63
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 64
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 65
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 73
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 75
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 75
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 77
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 77
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 77
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 82
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 83
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 87
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 88
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 1,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 91
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 92
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 94
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 95
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 97
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 98
+                              }
+                            }
+                          },
+                          {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 100
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 105
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 90
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 106
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 87
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 106
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 85
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 108
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 82
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 108
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 80
+              },
+              "end": {
+                "line": 1,
+                "column": 110
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 110
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 110
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 110
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectLiteralAssignability12.ts:1:100]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability12.ts b/es2panda/test/compiler/ts/objectLiteralAssignability12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3292b3b57f8b9a9f6c95d7751ed84213ed139fac
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability12.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: { a: number, b: string[] } } | { a: { a: number[], b: number } } = { a: { a: [1, 2, 3, "foo"] } }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability13-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5bc5c23ee35dd8761dc4c1de029fd3af27e420d9
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability13-expected.txt
@@ -0,0 +1,610 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 16
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 26
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 35
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 29
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 37
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 26
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 41
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 51
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 52
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 54
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 60
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 54
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 62
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 51
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 63
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 64
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 65
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 73
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 75
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 75
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 77
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 77
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 77
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 82
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 83
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 87
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 88
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 1,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 91
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 92
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 94
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 95
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 97
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 98
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 4,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 100
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 101
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 90
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 102
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 87
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 102
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 104
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 105
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 107
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 111
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 104
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 111
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 85
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 113
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 82
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 113
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 80
+              },
+              "end": {
+                "line": 1,
+                "column": 115
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 115
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 115
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 115
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'number'. [objectLiteralAssignability13.ts:1:104]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability13.ts b/es2panda/test/compiler/ts/objectLiteralAssignability13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f554ab1f538589b5efd190cb4da546167d9823b2
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability13.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: { a: number, b: string[] } } | { a: { a: number[], b: number } } = { a: { a: [1, 2, 3, 4], b: true } }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability14-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..08c5235393904f8da423150bff84feb7f3429d3f
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability14-expected.txt
@@ -0,0 +1,656 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 16
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 26
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 35
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 29
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 37
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 26
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 41
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 51
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 52
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSArrayType",
+                              "elementType": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 54
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 60
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 54
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 62
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 51
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 63
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 64
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 65
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 67
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 73
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 64
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 75
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 49
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 75
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 77
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 77
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 77
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 82
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 83
+                    }
+                  }
+                },
+                "value": {
+                  "type": "ObjectExpression",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 87
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 88
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "ArrayExpression",
+                        "elements": [
+                          {
+                            "type": "NumberLiteral",
+                            "value": 1,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 91
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 92
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 94
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 95
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 3,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 97
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 98
+                              }
+                            }
+                          },
+                          {
+                            "type": "NumberLiteral",
+                            "value": 4,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 100
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 101
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 90
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 102
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 87
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 102
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 104
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 105
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 107
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 108
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 104
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 108
+                        }
+                      }
+                    },
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": false,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 110
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 111
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 113
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 118
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 110
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 118
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 85
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 120
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 82
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 120
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 80
+              },
+              "end": {
+                "line": 1,
+                "column": 122
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 122
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 122
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 122
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'c' does not exist in type '{ a: number[]; b: number; } | { a: number; b: string[]; }' [objectLiteralAssignability14.ts:1:110]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability14.ts b/es2panda/test/compiler/ts/objectLiteralAssignability14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..15e677e8fbc48bf0c283d0fb405b0a941e2cf58d
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability14.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: { a: number, b: string[] } } | { a: { a: number[], b: number } } = { a: { a: [1, 2, 3, 4], b: 5, c: "foo" } }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability15-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..199052174fd3990b4159a29dbf0a4ca1adef6f66
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability15-expected.txt
@@ -0,0 +1,470 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 23
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 24
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": true,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 8,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 8
+                },
+                "end": {
+                  "line": 8,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 23
+          },
+          "end": {
+            "line": 9,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 21
+              },
+              "end": {
+                "line": 6,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 23
+            },
+            "end": {
+              "line": 6,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 12
+              },
+              "end": {
+                "line": 11,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 5
+            },
+            "end": {
+              "line": 11,
+              "column": 20
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 21
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [objectLiteralAssignability15.ts:11:14]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability15.ts b/es2panda/test/compiler/ts/objectLiteralAssignability15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bf0bb64c20b0a0180011912b60e1f8e0f75909b4
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability15.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: number | string,
+    b?: string,
+}
+
+interface b extends a {
+    a: string,
+    c: boolean
+}
+
+var a: b = { a: 5 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability16-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8013c23c763de5647a9360b2cc3238cab4d31123
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability16-expected.txt
@@ -0,0 +1,810 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 13
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 5
+                },
+                "end": {
+                  "line": 11,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 5
+                },
+                "end": {
+                  "line": 12,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 8
+                },
+                "end": {
+                  "line": 12,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 5
+                },
+                "end": {
+                  "line": 13,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 8
+                },
+                "end": {
+                  "line": 13,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 13
+          },
+          "end": {
+            "line": 14,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "c",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 11
+          },
+          "end": {
+            "line": 10,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 5
+                },
+                "end": {
+                  "line": 17,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 8
+                },
+                "end": {
+                  "line": 17,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 18,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 29
+          },
+          "end": {
+            "line": 18,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "d",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 21
+              },
+              "end": {
+                "line": 16,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 22
+            },
+            "end": {
+              "line": 16,
+              "column": 22
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 24
+              },
+              "end": {
+                "line": 16,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 25
+            },
+            "end": {
+              "line": 16,
+              "column": 25
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 27
+              },
+              "end": {
+                "line": 16,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 29
+            },
+            "end": {
+              "line": 16,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 8
+                },
+                "end": {
+                  "line": 20,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 15
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 18
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 21
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 28
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 28
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 31
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 37
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 37
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 12
+              },
+              "end": {
+                "line": 20,
+                "column": 39
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 5
+            },
+            "end": {
+              "line": 20,
+              "column": 39
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 40
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 20,
+      "column": 40
+    }
+  }
+}
+TypeError: Type '{ a: number; b: string; c: boolean; }' is not assignable to type 'd'. [objectLiteralAssignability16.ts:20:5]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability16.ts b/es2panda/test/compiler/ts/objectLiteralAssignability16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9295440fefcf9efe4d766b3dbc974809e064ff5c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability16.ts
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: number,
+}
+
+interface b {
+    a: number,
+    b: string,
+}
+
+interface c {
+    a: number,
+    b: string,
+    c: boolean
+}
+
+interface d extends a, b, c {
+    d: number
+}
+
+var a: d = { a: 5, b: "foo", c: true };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability17-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..410100f54fc280a3428faa4a8dbc919097324fa5
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability17-expected.txt
@@ -0,0 +1,384 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeQuery",
+                    "exprName": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 34
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 34
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '{ a: { a: number; b: string; }; b: string; }' is not assignable to type '{ a: number; b: string; }'. [objectLiteralAssignability17.ts:3:1]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability17.ts b/es2panda/test/compiler/ts/objectLiteralAssignability17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f337be03e89c58ebbcbe646a47c206fd124bf324
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability17.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number, b: string };
+var b: { a: typeof a, b: string };
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability18-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cfe5f73d6017ff91fdfdab35276e6a096a829a84
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability18-expected.txt
@@ -0,0 +1,814 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 42
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 18
+                },
+                "end": {
+                  "line": 1,
+                  "column": 42
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 47
+                },
+                "end": {
+                  "line": 1,
+                  "column": 53
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 44
+              },
+              "end": {
+                "line": 1,
+                "column": 45
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypeLiteral",
+          "members": [
+            {
+              "type": "TSPropertySignature",
+              "computed": false,
+              "optional": false,
+              "readonly": false,
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 58
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 59
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSArrayType",
+                "elementType": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 61
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 67
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 61
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 69
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 58
+                },
+                "end": {
+                  "line": 1,
+                  "column": 70
+                }
+              }
+            },
+            {
+              "type": "TSPropertySignature",
+              "computed": false,
+              "optional": false,
+              "readonly": false,
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 71
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 72
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 74
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 81
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 71
+                },
+                "end": {
+                  "line": 1,
+                  "column": 83
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 56
+            },
+            "end": {
+              "line": 1,
+              "column": 83
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 15
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "ArrayExpression",
+                      "elements": [
+                        {
+                          "type": "NumberLiteral",
+                          "value": 1,
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 19
+                            }
+                          }
+                        },
+                        {
+                          "type": "NumberLiteral",
+                          "value": 2,
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 22
+                            }
+                          }
+                        },
+                        {
+                          "type": "NumberLiteral",
+                          "value": 3,
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 25
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 26
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 26
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 35
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 38
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 84
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 35
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 38
+                },
+                "end": {
+                  "line": 5,
+                  "column": 42
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 49
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 49
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 52
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 54
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 59
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 59
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 61
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 6,
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 63
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 64
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 38
+              },
+              "end": {
+                "line": 5,
+                "column": 65
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 65
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 66
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 66
+    }
+  }
+}
+TypeError: Type '{ a: number[]; b: boolean; }' is not assignable to type '{ a: string[]; b: boolean; }' [objectLiteralAssignability18.ts:5:5]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability18.ts b/es2panda/test/compiler/ts/objectLiteralAssignability18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1f510c4f7438dfc8395fb42680628372eb456f53
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability18.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func(a: { a: number, b: string }, b: number): { a: number[], b: boolean } {
+    return { a: [1, 2, 3], b: true };
+}
+
+var a: { a: string[], b: boolean } = func({ a: 5, b: "foo" }, 6);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability19-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5606da9d4d8783a39b2af8a62eed4dc590bd9d21
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability19-expected.txt
@@ -0,0 +1,935 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 36
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 37
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 38
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 46
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 48
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 48
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 49
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 50
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 51
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 55
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 56
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 58
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 65
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 66
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 67
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 68
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNullKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 70
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 74
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 67
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 75
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 77
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 50
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 79
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 79
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 80
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 19
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 28
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 35
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 36
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 38
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 44
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 45
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 46
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 47
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 49
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 55
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 57
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 57
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 58
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 59
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 60
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 64
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 65
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTypeLiteral",
+                          "members": [
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 2,
+                                    "column": 69
+                                  },
+                                  "end": {
+                                    "line": 2,
+                                    "column": 70
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 2,
+                                    "column": 72
+                                  },
+                                  "end": {
+                                    "line": 2,
+                                    "column": 78
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 2,
+                                  "column": 69
+                                },
+                                "end": {
+                                  "line": 2,
+                                  "column": 79
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 2,
+                                    "column": 80
+                                  },
+                                  "end": {
+                                    "line": 2,
+                                    "column": 81
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 2,
+                                    "column": 83
+                                  },
+                                  "end": {
+                                    "line": 2,
+                                    "column": 89
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 2,
+                                  "column": 80
+                                },
+                                "end": {
+                                  "line": 2,
+                                  "column": 91
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 67
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 91
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 64
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 92
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "d",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 93
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 94
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 96
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 103
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 93
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 105
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 62
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 105
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 59
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 107
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 107
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 108
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '{ a: number | string; b: { a: number; b: number; }; c: { a: { a: number; b: string; }; d: boolean; }; }' is not assignable to type '{ a: number; b: { a: number; b: string; }; c: { b: boolean; a: null; }; }'. [objectLiteralAssignability19.ts:3:1]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability19.ts b/es2panda/test/compiler/ts/objectLiteralAssignability19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..de6b7a9dc188e5e2244dbb0a01b83f0396ec6cb5
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability19.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number, b: { a: number, b: string }, c: { b: boolean, a: null, } };
+var b: { a: number | string, b: { a: number, b: number }, c: { a: { a: number, b: string }, d: boolean } };
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability2-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dbe519596dccc08c8fe645fcc0f3ed12d7f52b73
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability2-expected.txt
@@ -0,0 +1,226 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 30
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 30
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 40
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 40
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 24
+              },
+              "end": {
+                "line": 1,
+                "column": 42
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 42
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 43
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 43
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }' [objectLiteralAssignability2.ts:1:32]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability2.ts b/es2panda/test/compiler/ts/objectLiteralAssignability2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..70f66898c226c0c7b2d778b09a52ccde9db67bf7
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number } = { a: 5, b: "foo" };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability20-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7b3c365e1993c36291163bee07bd8ed0c55a58b9
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability20-expected.txt
@@ -0,0 +1,477 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 36
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 39
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 58
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 49
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 50
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 61
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 36
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 39
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 58
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 49
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 50
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 61
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 61
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '{ (a: string, b: string): any; new (a: number, b: string): any; }' is not assignable to type '{ (a: number, b: string): any; new (a: number, b: string): any; }'. [objectLiteralAssignability20.ts:3:1]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability20.ts b/es2panda/test/compiler/ts/objectLiteralAssignability20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4b952942a472e8070510b3dddae423e31ed15ad4
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability20.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { new(a: number, b: string), (a: number, b: string) };
+var b: { new(a: number, b: string), (a: string, b: string) }
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability3-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..76b5095e3f8d3480271621938bbf0dd7f4f73804
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability3-expected.txt
@@ -0,0 +1,254 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 21
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 37
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 37
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 37
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 43
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 49
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 49
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 40
+              },
+              "end": {
+                "line": 1,
+                "column": 51
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 51
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 52
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 52
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'c' does not exist in type '{ a: number; } | { b: string; }' [objectLiteralAssignability3.ts:1:42]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability3.ts b/es2panda/test/compiler/ts/objectLiteralAssignability3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b70bda3f8350718af85b4e8b04ab3a3a5c854cc6
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number } | { b: string } = { c: true };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability4-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8273d0c8356aa685bee90dfffe46dadb6b71770c
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability4-expected.txt
@@ -0,0 +1,252 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 31
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "returnType": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 41
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 51
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 56
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 44
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 56
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 58
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 58
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 58
+                    }
+                  }
+                },
+                "kind": "get",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 58
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 24
+              },
+              "end": {
+                "line": 1,
+                "column": 60
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 60
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 60
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 60
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [objectLiteralAssignability4.ts:1:26]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability4.ts b/es2panda/test/compiler/ts/objectLiteralAssignability4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2076c5eff351396bd82a8140129c43323f02720f
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { b: number } = { get b(): string { return "foo" } }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability5-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5514dba56a91f4987c279a26b0b91e5376b818e3
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability5-expected.txt
@@ -0,0 +1,565 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 12
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 15
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 18
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 25
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 27
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 27
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 42
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 53
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 56
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 62
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 62
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 64
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 64
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "SpreadElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 72
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 73
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 69
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 73
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 75
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 76
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 78
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 79
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 75
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 79
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 81
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 82
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 85
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 81
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 85
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 67
+              },
+              "end": {
+                "line": 2,
+                "column": 87
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 87
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 88
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 88
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean | string'. [objectLiteralAssignability5.ts:2:81]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability5.ts b/es2panda/test/compiler/ts/objectLiteralAssignability5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..85a68b17ffa0e790f1575152cae1fda4098d41c3
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability5.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = { a: 5, b: "foo" };
+var b: { a: number, b: string, c: number, d: boolean | string } = { ...a, c: 5, d: 6 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability6-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c1c94fd55c63d3e69970556959b0afd1430b1973
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability6-expected.txt
@@ -0,0 +1,342 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 46
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 49
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 51
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 57
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 59
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 59
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 64
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 65
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 67
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 71
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 64
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 71
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 62
+              },
+              "end": {
+                "line": 1,
+                "column": 73
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 73
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 74
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 74
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string | number'. [objectLiteralAssignability6.ts:1:64]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability6.ts b/es2panda/test/compiler/ts/objectLiteralAssignability6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c6560098c2d78793a3d6272ff51166c029e72036
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number, b: string } | { a: string, b: number } = { a: true };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability7-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e39674a936e32769fd31e96ffdd53f0574cbf530
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability7-expected.txt
@@ -0,0 +1,313 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 21
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 37
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 37
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 42
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 43
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 45
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 54
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 54
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 54
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 59
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 60
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 62
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 67
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 59
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 67
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 57
+              },
+              "end": {
+                "line": 1,
+                "column": 69
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 69
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 70
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 70
+    }
+  }
+}
+TypeError: Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; } | { a: string; } | { a: boolean; }' [objectLiteralAssignability7.ts:1:59]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability7.ts b/es2panda/test/compiler/ts/objectLiteralAssignability7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..14d20e8460c771e8ec22c8e5b950e7dfad548a8d
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number } | { a: string } | { a: boolean } = { b: "foo" };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability8-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fbc9a13d13b25fd0eabec476f0bcf7db26d1b980
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability8-expected.txt
@@ -0,0 +1,492 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 46
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 49
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 51
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 57
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 48
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 59
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 59
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 64
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 65
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 67
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 74
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 64
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 75
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 76
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 77
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 79
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 86
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 76
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 88
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 62
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 88
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 88
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 93
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 94
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 96
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 101
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 93
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 101
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 103
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 104
+                    }
+                  }
+                },
+                "value": {
+                  "type": "BigIntLiteral",
+                  "value": "",
+                  "bigint": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 106
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 108
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 103
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 108
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 91
+              },
+              "end": {
+                "line": 1,
+                "column": 110
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 110
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 111
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 111
+    }
+  }
+}
+TypeError: Type 'bigint' is not assignable to type 'string'. [objectLiteralAssignability8.ts:1:103]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability8.ts b/es2panda/test/compiler/ts/objectLiteralAssignability8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d4aa659b1deed5890d84269c737e4cfc4c7a29e4
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability8.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { b: number, a: number } | { b: string, a: string } | { b: boolean, a: boolean } = { b: "foo", a: 5n };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability9-expected.txt b/es2panda/test/compiler/ts/objectLiteralAssignability9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..30d0f5575232c85557257f0a6852eecd5d89dbed
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability9-expected.txt
@@ -0,0 +1,270 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 25
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 37
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 45
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 48
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 48
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 42
+              },
+              "end": {
+                "line": 1,
+                "column": 50
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 50
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 51
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 51
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type '{ a: number; b: string; }'. [objectLiteralAssignability9.ts:1:44]
diff --git a/es2panda/test/compiler/ts/objectLiteralAssignability9.ts b/es2panda/test/compiler/ts/objectLiteralAssignability9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..024e8edf90a756dc893353084b8b1ae90893f604
--- /dev/null
+++ b/es2panda/test/compiler/ts/objectLiteralAssignability9.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: { a: number, b: string } } = { a: 5 };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/recursiveFunction-expected.txt b/es2panda/test/compiler/ts/recursiveFunction-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..622270f811d16090464dad86247379f34b129221
--- /dev/null
+++ b/es2panda/test/compiler/ts/recursiveFunction-expected.txt
@@ -0,0 +1,508 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 28
+                },
+                "end": {
+                  "line": 1,
+                  "column": 34
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "VariableDeclaration",
+              "declarations": [
+                {
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 18
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "init": {
+                    "type": "CallExpression",
+                    "callee": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "arguments": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 26
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 33
+                          }
+                        }
+                      }
+                    ],
+                    "optional": false,
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 34
+                    }
+                  }
+                }
+              ],
+              "kind": "var",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 35
+                }
+              }
+            },
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "CallExpression",
+                "callee": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 15
+                    }
+                  }
+                },
+                "arguments": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 17
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 24
+                      }
+                    }
+                  }
+                ],
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 25
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 26
+                }
+              }
+            },
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "NumberLiteral",
+                "value": 12,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 36
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 9
+                },
+                "end": {
+                  "line": 8,
+                  "column": 12
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 9
+              },
+              "end": {
+                "line": 8,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 23
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/recursiveFunction.ts b/es2panda/test/compiler/ts/recursiveFunction.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a11d766b9a7eece2fe90e3311075786b15901f2b
--- /dev/null
+++ b/es2panda/test/compiler/ts/recursiveFunction.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a: number, b: string) {
+    var a: number = foo(1, "bar");
+    return foo(2, "baz");
+    return 12;
+}
+
+var b: any;
+var b = foo(2, "bar");
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/recursiveTypeofWithProperty-expected.txt b/es2panda/test/compiler/ts/recursiveTypeofWithProperty-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dfa118d3fca112cbda7b30f92c36fee37b9f8df6
--- /dev/null
+++ b/es2panda/test/compiler/ts/recursiveTypeofWithProperty-expected.txt
@@ -0,0 +1,746 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "t",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 10
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTypeQuery",
+                          "exprName": {
+                            "type": "TSQualifiedName",
+                            "left": {
+                              "type": "TSQualifiedName",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "o",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 3,
+                                    "column": 19
+                                  },
+                                  "end": {
+                                    "line": 3,
+                                    "column": 20
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 3,
+                                    "column": 21
+                                  },
+                                  "end": {
+                                    "line": 3,
+                                    "column": 22
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 3,
+                                  "column": 19
+                                },
+                                "end": {
+                                  "line": 3,
+                                  "column": 22
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "Identifier",
+                              "name": "c",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 3,
+                                  "column": 23
+                                },
+                                "end": {
+                                  "line": 3,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 3,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 3,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 25
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 25
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "z",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 10
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTypeQuery",
+                          "exprName": {
+                            "type": "TSQualifiedName",
+                            "left": {
+                              "type": "TSQualifiedName",
+                              "left": {
+                                "type": "TSQualifiedName",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "o",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 4,
+                                      "column": 19
+                                    },
+                                    "end": {
+                                      "line": 4,
+                                      "column": 20
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "Identifier",
+                                  "name": "b",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 4,
+                                      "column": 21
+                                    },
+                                    "end": {
+                                      "line": 4,
+                                      "column": 22
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 19
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 22
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "Identifier",
+                                "name": "k",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 4,
+                                    "column": 23
+                                  },
+                                  "end": {
+                                    "line": 4,
+                                    "column": 24
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 4,
+                                  "column": 19
+                                },
+                                "end": {
+                                  "line": 4,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "Identifier",
+                              "name": "t",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 4,
+                                  "column": 25
+                                },
+                                "end": {
+                                  "line": 4,
+                                  "column": 26
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 4,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 5,
+                                "column": 6
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 6
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 6
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 7
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 10
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTypeQuery",
+                          "exprName": {
+                            "type": "TSQualifiedName",
+                            "left": {
+                              "type": "TSQualifiedName",
+                              "left": {
+                                "type": "Identifier",
+                                "name": "o",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 7,
+                                    "column": 19
+                                  },
+                                  "end": {
+                                    "line": 7,
+                                    "column": 20
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 7,
+                                    "column": 21
+                                  },
+                                  "end": {
+                                    "line": 7,
+                                    "column": 22
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 7,
+                                  "column": 19
+                                },
+                                "end": {
+                                  "line": 7,
+                                  "column": 22
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "Identifier",
+                              "name": "z",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 7,
+                                  "column": 23
+                                },
+                                "end": {
+                                  "line": 7,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 7,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 7,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 25
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 25
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "k",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 10
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTypeLiteral",
+                          "members": [
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "t",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 9,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 9,
+                                    "column": 14
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSTypeQuery",
+                                "exprName": {
+                                  "type": "TSQualifiedName",
+                                  "left": {
+                                    "type": "TSQualifiedName",
+                                    "left": {
+                                      "type": "Identifier",
+                                      "name": "o",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 9,
+                                          "column": 23
+                                        },
+                                        "end": {
+                                          "line": 9,
+                                          "column": 24
+                                        }
+                                      }
+                                    },
+                                    "right": {
+                                      "type": "Identifier",
+                                      "name": "a",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 9,
+                                          "column": 25
+                                        },
+                                        "end": {
+                                          "line": 9,
+                                          "column": 26
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 9,
+                                        "column": 23
+                                      },
+                                      "end": {
+                                        "line": 9,
+                                        "column": 26
+                                      }
+                                    }
+                                  },
+                                  "right": {
+                                    "type": "Identifier",
+                                    "name": "t",
+                                    "decorators": [],
+                                    "loc": {
+                                      "start": {
+                                        "line": 9,
+                                        "column": 27
+                                      },
+                                      "end": {
+                                        "line": 9,
+                                        "column": 28
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 9,
+                                      "column": 23
+                                    },
+                                    "end": {
+                                      "line": 9,
+                                      "column": 29
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 9,
+                                    "column": 16
+                                  },
+                                  "end": {
+                                    "line": 9,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 9,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 9,
+                                  "column": 29
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "r",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 10,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 10,
+                                    "column": 14
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 10,
+                                    "column": 16
+                                  },
+                                  "end": {
+                                    "line": 10,
+                                    "column": 22
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 10,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 11,
+                                  "column": 10
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 11,
+                              "column": 10
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 6
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 2
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 13,
+                  "column": 2
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 3
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 14,
+      "column": 1
+    }
+  }
+}
+TypeError: 'z' is referenced directly or indirectly in its own type annotation. [recursiveTypeofWithProperty.ts:7:23]
diff --git a/es2panda/test/compiler/ts/recursiveTypeofWithProperty.ts b/es2panda/test/compiler/ts/recursiveTypeofWithProperty.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dde2d56578239f2d3ef1095552bece24c70161cf
--- /dev/null
+++ b/es2panda/test/compiler/ts/recursiveTypeofWithProperty.ts
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var o: {
+    a: {
+        t: typeof o.b.c,
+        z: typeof o.b.k.t
+    },
+    b: {
+        c: typeof o.a.z,
+        k: {
+            t: typeof o.a.t,
+            r: number
+        }
+    }
+};
diff --git a/es2panda/test/compiler/ts/test-interface-expected.txt b/es2panda/test/compiler/ts/test-interface-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8e5ff32590dc655ce4d3de8c19b020c6da8b07a3
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface-expected.txt
@@ -0,0 +1,1081 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": true,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSMethodSignature",
+            "computed": false,
+            "optional": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSFunctionType",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 12
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSVoidKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 23
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 40
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 54
+                    }
+                  }
+                },
+                "optional": true,
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 43
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUndefinedKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 57
+                },
+                "end": {
+                  "line": 4,
+                  "column": 66
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 67
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 18
+                },
+                "end": {
+                  "line": 5,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 18
+                },
+                "end": {
+                  "line": 6,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSMethodSignature",
+            "computed": false,
+            "optional": false,
+            "key": {
+              "type": "Identifier",
+              "name": "readonly",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 13
+                }
+              }
+            },
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 24
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 16
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 27
+                },
+                "end": {
+                  "line": 7,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 34
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "a",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 14
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 6
+                },
+                "end": {
+                  "line": 8,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 16
+                },
+                "end": {
+                  "line": 8,
+                  "column": 22
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNullKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 16
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 28
+                    }
+                  }
+                },
+                "optional": true,
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 43
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 44
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 45
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 53
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 54
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 55
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 56
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 59
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 60
+                            }
+                          }
+                        },
+                        {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 62
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 63
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 58
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 64
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 73
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 75
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 31
+                },
+                "end": {
+                  "line": 9,
+                  "column": 75
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 15
+          },
+          "end": {
+            "line": 10,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": true,
+            "readonly": true,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 14
+                },
+                "end": {
+                  "line": 13,
+                  "column": 15
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 18
+                },
+                "end": {
+                  "line": 13,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": true,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 14
+                },
+                "end": {
+                  "line": 14,
+                  "column": 15
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 23
+                    }
+                  }
+                },
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 17
+                },
+                "end": {
+                  "line": 14,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 34
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "a",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 23
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 15
+                },
+                "end": {
+                  "line": 15,
+                  "column": 16
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 25
+                },
+                "end": {
+                  "line": 15,
+                  "column": 31
+                }
+              }
+            },
+            "readonly": true,
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 16,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 15
+          },
+          "end": {
+            "line": 16,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "bar",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 11
+          },
+          "end": {
+            "line": 12,
+            "column": 14
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 16,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/test-interface.ts b/es2panda/test/compiler/ts/test-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a7254fecbd16d446a4b7103deed687ef4f5a6b10
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface.ts
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface foo {
+    a?: number,
+    b: string | boolean;
+    c(a: (a: number, b: void) => string, b?: number[]): undefined;
+    (a: string): string,
+    (a: number): number,
+    readonly (a: number): number,
+    [a:number]:number,
+    new(a: null, b?: string): { a: number, b: string, c?([a, b]): string }
+}
+
+interface bar {
+    readonly a?: number,
+    readonly b: string | boolean;
+    readonly [a:number]:number
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-interface4-expected.txt b/es2panda/test/compiler/ts/test-interface4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b80117748bd917ef33dce403167c378649e17844
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected [test-interface4.ts:1:27]
diff --git a/es2panda/test/compiler/ts/test-interface4.ts b/es2panda/test/compiler/ts/test-interface4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f06e70caf37cb8cd8b254121afc5ec34d19b9e15
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A { [a: number] ?: number }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-interface5-expected.txt b/es2panda/test/compiler/ts/test-interface5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6c41402d92b311c996175f42bb091c52c85ad6e3
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'readonly' modifier can only appear on a property declaration or index signature. [test-interface5.ts:1:15]
diff --git a/es2panda/test/compiler/ts/test-interface5.ts b/es2panda/test/compiler/ts/test-interface5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1043bc70b04d8d27969e5219306de9da7d9a64a2
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A { readonly new(a: number): string };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-interface6-expected.txt b/es2panda/test/compiler/ts/test-interface6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d55b07ee8878eb85b723c09d776bf1653cd1b54
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'readonly' modifier can only appear on a property declaration or index signature. [test-interface6.ts:1:15]
diff --git a/es2panda/test/compiler/ts/test-interface6.ts b/es2panda/test/compiler/ts/test-interface6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b11e1740658171536ee6aff6f39aa339be6ddcb
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A { readonly a(a: number): string };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-interface7-expected.txt b/es2panda/test/compiler/ts/test-interface7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..969f7021d26bfd4bb43d31eed4022c56c5ee00ae
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: An index signature must have a type annotation. [test-interface7.ts:1:15]
diff --git a/es2panda/test/compiler/ts/test-interface7.ts b/es2panda/test/compiler/ts/test-interface7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b8cbd72e74f765c614615db24903eb39e57e5083
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-interface7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface A { [a: number] };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-type-literal-expected.txt b/es2panda/test/compiler/ts/test-type-literal-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eecb754c17104d80c390f9748e3ef6cc7f9232b5
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal-expected.txt
@@ -0,0 +1,1721 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 57
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 60
+                        }
+                      }
+                    },
+                    {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 63
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 64
+                            }
+                          }
+                        },
+                        {
+                          "type": "Identifier",
+                          "name": "d",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 66
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 67
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 62
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 68
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "k",
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 70
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 71
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 56
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 75
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 75
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 21
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 13
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 32
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 36
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "d",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 48
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 39
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "e",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 51
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "g",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 58
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 56
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "l",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 69
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 75
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 66
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 67
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 80
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 86
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 86
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 88
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 88
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": true,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": true,
+                  "optional": false,
+                  "key": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSUndefinedKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 44
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 33
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 47
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSNullKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 60
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 62
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 43
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "NumberLiteral",
+                    "value": 6,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 44
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 45
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 55
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 23
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": true,
+                  "key": {
+                    "type": "NumberLiteral",
+                    "value": 7,
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 55
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 58
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 64
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 65
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": true,
+                  "key": {
+                    "type": "NumberLiteral",
+                    "value": 8,
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 75
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 76
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 79
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 85
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 66
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 86
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 86
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 87
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 18
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "readonly": false,
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "readonly",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 46
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 39
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 55
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 8
+                },
+                "end": {
+                  "line": 8,
+                  "column": 55
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 56
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "g",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSIndexSignature",
+                  "parameters": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "readonly": true,
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 36
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 8
+                },
+                "end": {
+                  "line": 9,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 37
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 9,
+      "column": 37
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/test-type-literal.ts b/es2panda/test/compiler/ts/test-type-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9d0f8196e447026623ef5c8edc359abe2a983ba8
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal.ts
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { new(a: number, b: string): number; a: string; b?(a, [c, d], k?) }
+var b: { a: number, b: number; c?: string }
+var c: { a(a: number, b: string[]), (d: boolean, e): (g: number, l: string) => string }
+var d: { ["foo"]: boolean, [5](a: undefined, b?: any): null }
+var e: { a: number, 5: number; b?: string, 6?: number,
+    readonly c: number, readonly 7: number; readonly d?: string, readonly 8?: number};
+
+var f: {[a:number]:number, readonly (a:number):string};
+var g: {readonly [a:number]:number};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-type-literal4-expected.txt b/es2panda/test/compiler/ts/test-type-literal4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a009866db586a4c154f03ee9a66a3b8fb042a7f9
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected [test-type-literal4.ts:1:21]
diff --git a/es2panda/test/compiler/ts/test-type-literal4.ts b/es2panda/test/compiler/ts/test-type-literal4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56ef821ced4b9919c1b5c3d360976c5e492b67d4
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { [a:number] ?: number }
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-type-literal5-expected.txt b/es2panda/test/compiler/ts/test-type-literal5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b731ac04d0337c51b2d23128798a0abf61e688ae
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'readonly' modifier can only appear on a property declaration or index signature. [test-type-literal5.ts:1:10]
diff --git a/es2panda/test/compiler/ts/test-type-literal5.ts b/es2panda/test/compiler/ts/test-type-literal5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..80e50cf15bdd091227de7c52eeb88306baf087d2
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { readonly new (a:number):string };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-type-literal6-expected.txt b/es2panda/test/compiler/ts/test-type-literal6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c1368f4c650d9ab8dc1c795e1af75832395ab47e
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'readonly' modifier can only appear on a property declaration or index signature. [test-type-literal6.ts:1:10]
diff --git a/es2panda/test/compiler/ts/test-type-literal6.ts b/es2panda/test/compiler/ts/test-type-literal6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2c11025efa4245abdb4e83022d08944e00415a2f
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { readonly a(a:number):string };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/test-type-literal7-expected.txt b/es2panda/test/compiler/ts/test-type-literal7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3a2912298c55e3a18913bb4f7a66440a71cd8de
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: An index signature must have a type annotation. [test-type-literal7.ts:1:10]
diff --git a/es2panda/test/compiler/ts/test-type-literal7.ts b/es2panda/test/compiler/ts/test-type-literal7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..59d84e207cca15f9da3c43d65fd9e6773a23742f
--- /dev/null
+++ b/es2panda/test/compiler/ts/test-type-literal7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { [a:number] };
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability-expected.txt b/es2panda/test/compiler/ts/tupleAssignability-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ffacf20ca95c868f73826d6450aee3ebf419ae40
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability-expected.txt
@@ -0,0 +1,7985 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple1",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 13
+                },
+                "end": {
+                  "line": 1,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 18
+              },
+              "end": {
+                "line": 1,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 20
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple2",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSTupleType",
+                      "elementTypes": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 18
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 19
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 26
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 27
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 22
+              },
+              "end": {
+                "line": 2,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple3",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 37
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 13
+                },
+                "end": {
+                  "line": 3,
+                  "column": 37
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 42
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 45
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 48
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 40
+              },
+              "end": {
+                "line": 3,
+                "column": 49
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 49
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple4",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "tuple1",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 28
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 36
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 13
+                },
+                "end": {
+                  "line": 4,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 42
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 49
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 39
+              },
+              "end": {
+                "line": 4,
+                "column": 50
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 50
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple5",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 25
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 37
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 38
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 47
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 50
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 56
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 40
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 57
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 58
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 64
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 58
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 67
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 68
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 13
+                },
+                "end": {
+                  "line": 5,
+                  "column": 68
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 73
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 74
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 75
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 78
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 83
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 86
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 87
+                          }
+                        }
+                      },
+                      {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 89
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 90
+                          }
+                        }
+                      },
+                      {
+                        "type": "NumberLiteral",
+                        "value": 3,
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 92
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 93
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 85
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 94
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 77
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 95
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 71
+              },
+              "end": {
+                "line": 5,
+                "column": 96
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 96
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 97
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple6",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 21
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 13
+                },
+                "end": {
+                  "line": 7,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 37
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 35
+              },
+              "end": {
+                "line": 7,
+                "column": 38
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 38
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple7",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 21
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 29
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 38
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 47
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 13
+                },
+                "end": {
+                  "line": 8,
+                  "column": 47
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 51
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 52
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 54
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 59
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 50
+              },
+              "end": {
+                "line": 8,
+                "column": 60
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 60
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple8",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSParenthesizedType",
+                    "typeAnnotation": {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 21
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSTypeLiteral",
+                          "members": [
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 9,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 9,
+                                    "column": 27
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 9,
+                                    "column": 29
+                                  },
+                                  "end": {
+                                    "line": 9,
+                                    "column": 35
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 9,
+                                  "column": 26
+                                },
+                                "end": {
+                                  "line": 9,
+                                  "column": 36
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSPropertySignature",
+                              "computed": false,
+                              "optional": false,
+                              "readonly": false,
+                              "key": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 9,
+                                    "column": 37
+                                  },
+                                  "end": {
+                                    "line": 9,
+                                    "column": 38
+                                  }
+                                }
+                              },
+                              "typeAnnotation": {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 9,
+                                    "column": 40
+                                  },
+                                  "end": {
+                                    "line": 9,
+                                    "column": 46
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 9,
+                                  "column": 37
+                                },
+                                "end": {
+                                  "line": 9,
+                                  "column": 48
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 48
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 48
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 51
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 55
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 62
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 63
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 69
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 72
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 78
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 63
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 79
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 54
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 79
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 13
+                },
+                "end": {
+                  "line": 9,
+                  "column": 79
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "BooleanLiteral",
+                "value": false,
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 83
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 88
+                  }
+                }
+              },
+              {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 92
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 93
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 95
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 96
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 92
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 96
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 98
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 99
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 101
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 106
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 98
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 106
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 90
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 108
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 82
+              },
+              "end": {
+                "line": 9,
+                "column": 109
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 109
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 110
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple9",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 28
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 37
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 38
+                    }
+                  }
+                },
+                {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSBooleanKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 46
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 49
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 55
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 56
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 13
+                },
+                "end": {
+                  "line": 11,
+                  "column": 56
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 11
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 5
+            },
+            "end": {
+              "line": 11,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 57
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple10",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 14
+                },
+                "end": {
+                  "line": 12,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 5
+            },
+            "end": {
+              "line": 12,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple11",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 35
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 44
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 45
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 49
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 56
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 57
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 14
+                },
+                "end": {
+                  "line": 13,
+                  "column": 57
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 5
+            },
+            "end": {
+              "line": 13,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 58
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple12",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 36
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 38
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 48
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 56
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 49
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 57
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 14
+                },
+                "end": {
+                  "line": 14,
+                  "column": 57
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 58
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple13",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 26
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 38
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 50
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 14
+                },
+                "end": {
+                  "line": 15,
+                  "column": 50
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 15,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 5
+            },
+            "end": {
+              "line": 15,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple10",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 10
+            },
+            "end": {
+              "line": 17,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple11",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 10
+            },
+            "end": {
+              "line": 18,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 10
+            },
+            "end": {
+              "line": 19,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple11",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 11
+            },
+            "end": {
+              "line": 20,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple13",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 11
+            },
+            "end": {
+              "line": 21,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple13",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple13",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 11
+            },
+            "end": {
+              "line": 22,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple12",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "TSAsExpression",
+          "expression": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 13
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 26
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 6,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 32
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 11
+              },
+              "end": {
+                "line": 23,
+                "column": 33
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSTupleType",
+            "elementTypes": [
+              {
+                "type": "TSNamedTupleMember",
+                "elementType": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 47
+                    }
+                  }
+                },
+                "label": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 39
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 48
+                  }
+                }
+              },
+              {
+                "type": "TSNamedTupleMember",
+                "elementType": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 52
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 58
+                    }
+                  }
+                },
+                "label": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 50
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 59
+                  }
+                }
+              },
+              {
+                "type": "TSNamedTupleMember",
+                "elementType": {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 63
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 70
+                    }
+                  }
+                },
+                "label": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 61
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 60
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 71
+                  }
+                }
+              },
+              {
+                "type": "TSNamedTupleMember",
+                "elementType": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 75
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 81
+                    }
+                  }
+                },
+                "label": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 72
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 73
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 82
+                  }
+                }
+              },
+              {
+                "type": "TSNamedTupleMember",
+                "elementType": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 87
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 93
+                    }
+                  }
+                },
+                "label": {
+                  "type": "Identifier",
+                  "name": "e",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 83
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 84
+                    }
+                  }
+                },
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 83
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 94
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 37
+              },
+              "end": {
+                "line": 23,
+                "column": 94
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 11
+            },
+            "end": {
+              "line": 23,
+              "column": 95
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 95
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 95
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple14",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 12
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 18
+                        }
+                      }
+                    },
+                    {
+                      "type": "NumberLiteral",
+                      "value": 2,
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 21
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "CallExpression",
+                  "callee": {
+                    "type": "Identifier",
+                    "name": "func1",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "arguments": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 1,
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 31
+                        }
+                      }
+                    },
+                    {
+                      "type": "StringLiteral",
+                      "value": "",
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 38
+                        }
+                      }
+                    }
+                  ],
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 39
+                    }
+                  }
+                },
+                {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 45
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 15
+                },
+                "end": {
+                  "line": 25,
+                  "column": 46
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 56
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 63
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 64
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 71
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 55
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 71
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 51
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 51
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 72
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSNamedTupleMember",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 25,
+                              "column": 81
+                            },
+                            "end": {
+                              "line": 25,
+                              "column": 87
+                            }
+                          }
+                        },
+                        "label": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 25,
+                              "column": 78
+                            },
+                            "end": {
+                              "line": 25,
+                              "column": 79
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 78
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 88
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSNamedTupleMember",
+                        "elementType": {
+                          "type": "TSArrayType",
+                          "elementType": {
+                            "type": "TSBooleanKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 25,
+                                "column": 93
+                              },
+                              "end": {
+                                "line": 25,
+                                "column": 100
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 25,
+                              "column": 93
+                            },
+                            "end": {
+                              "line": 25,
+                              "column": 102
+                            }
+                          }
+                        },
+                        "label": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 25,
+                              "column": 89
+                            },
+                            "end": {
+                              "line": 25,
+                              "column": 90
+                            }
+                          }
+                        },
+                        "optional": true,
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 89
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 103
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 77
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 103
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 73
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 74
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 73
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 104
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 109
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 116
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 105
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 106
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 105
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 117
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 50
+                },
+                "end": {
+                  "line": 25,
+                  "column": 117
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 15
+              },
+              "end": {
+                "line": 25,
+                "column": 118
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 118
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 118
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 1
+            },
+            "end": {
+              "line": 26,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 11
+            },
+            "end": {
+              "line": 26,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 12
+                },
+                "end": {
+                  "line": 27,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 11
+            },
+            "end": {
+              "line": 27,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 1
+            },
+            "end": {
+              "line": 28,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 3,
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 4,
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 12
+                },
+                "end": {
+                  "line": 28,
+                  "column": 18
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 22
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 20
+                },
+                "end": {
+                  "line": 28,
+                  "column": 23
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 11
+            },
+            "end": {
+              "line": 28,
+              "column": 24
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 1
+          },
+          "end": {
+            "line": 28,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 1
+            },
+            "end": {
+              "line": 29,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 7,
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 12
+                },
+                "end": {
+                  "line": 29,
+                  "column": 18
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 8,
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 29
+                        }
+                      }
+                    },
+                    {
+                      "type": "BooleanLiteral",
+                      "value": false,
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 36
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 37
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 20
+                },
+                "end": {
+                  "line": 29,
+                  "column": 38
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 11
+            },
+            "end": {
+              "line": 29,
+              "column": 39
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 39
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple14",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 1
+            },
+            "end": {
+              "line": 30,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 9,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 10,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 18
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 12
+                },
+                "end": {
+                  "line": 30,
+                  "column": 19
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 11,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "BooleanLiteral",
+                      "value": true,
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 31
+                        }
+                      }
+                    },
+                    {
+                      "type": "BooleanLiteral",
+                      "value": false,
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 38
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 21
+                },
+                "end": {
+                  "line": 30,
+                  "column": 40
+                }
+              }
+            },
+            {
+              "type": "BooleanLiteral",
+              "value": true,
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 42
+                },
+                "end": {
+                  "line": 30,
+                  "column": 46
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 11
+            },
+            "end": {
+              "line": 30,
+              "column": 47
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 1
+          },
+          "end": {
+            "line": 30,
+            "column": 47
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 48
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 10
+            },
+            "end": {
+              "line": 32,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 19
+                },
+                "end": {
+                  "line": 32,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 16
+              },
+              "end": {
+                "line": 32,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 30
+                },
+                "end": {
+                  "line": 32,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 27
+              },
+              "end": {
+                "line": 32,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSNamedTupleMember",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 49
+                  }
+                }
+              },
+              "label": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 41
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 40
+                },
+                "end": {
+                  "line": 32,
+                  "column": 50
+                }
+              }
+            },
+            {
+              "type": "TSNamedTupleMember",
+              "elementType": {
+                "type": "TSArrayType",
+                "elementType": {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 62
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 64
+                  }
+                }
+              },
+              "label": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 51
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 52
+                  }
+                }
+              },
+              "optional": true,
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 51
+                },
+                "end": {
+                  "line": 32,
+                  "column": 65
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 39
+            },
+            "end": {
+              "line": 32,
+              "column": 65
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "VariableDeclaration",
+              "declarations": [
+                {
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "tuple15",
+                    "typeAnnotation": {
+                      "type": "TSTupleType",
+                      "elementTypes": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 26
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 26
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "init": null,
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 16
+                    }
+                  }
+                }
+              ],
+              "kind": "let",
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 5
+                },
+                "end": {
+                  "line": 33,
+                  "column": 27
+                }
+              }
+            },
+            {
+              "type": "ExpressionStatement",
+              "expression": {
+                "type": "AssignmentExpression",
+                "operator": "=",
+                "left": {
+                  "type": "Identifier",
+                  "name": "tuple15",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 12
+                    }
+                  }
+                },
+                "right": {
+                  "type": "ArrayExpression",
+                  "elements": [
+                    {
+                      "type": "NumberLiteral",
+                      "value": 123,
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 19
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 5
+                },
+                "end": {
+                  "line": 34,
+                  "column": 21
+                }
+              }
+            },
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "Identifier",
+                "name": "tuple15",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 5
+                },
+                "end": {
+                  "line": 35,
+                  "column": 20
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 66
+            },
+            "end": {
+              "line": 36,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 1
+          },
+          "end": {
+            "line": 36,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple16",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "tuple10",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 38,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 38,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "tuple1",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 38,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 38,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 45
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 53
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 14
+                },
+                "end": {
+                  "line": 38,
+                  "column": 53
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 5
+              },
+              "end": {
+                "line": 38,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 5
+            },
+            "end": {
+              "line": 38,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 54
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 10
+            },
+            "end": {
+              "line": 40,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "tuple16",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 33
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 19
+                },
+                "end": {
+                  "line": 40,
+                  "column": 33
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 16
+              },
+              "end": {
+                "line": 40,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 40,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 40,
+                      "column": 47
+                    }
+                  }
+                },
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 40,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 40,
+                      "column": 56
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 39
+                },
+                "end": {
+                  "line": 40,
+                  "column": 56
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 35
+              },
+              "end": {
+                "line": 40,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "func2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 67
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 72
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 60
+                },
+                "end": {
+                  "line": 40,
+                  "column": 73
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 74
+                },
+                "end": {
+                  "line": 40,
+                  "column": 81
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 59
+            },
+            "end": {
+              "line": 40,
+              "column": 81
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "func2",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 18
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 5
+                },
+                "end": {
+                  "line": 41,
+                  "column": 27
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 82
+            },
+            "end": {
+              "line": 42,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 42,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 42,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple17",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 44,
+                "column": 5
+              },
+              "end": {
+                "line": 44,
+                "column": 12
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func2",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 44,
+                  "column": 15
+                },
+                "end": {
+                  "line": 44,
+                  "column": 20
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 44,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 44,
+                            "column": 24
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 44,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 44,
+                            "column": 31
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 44,
+                            "column": 33
+                          },
+                          "end": {
+                            "line": 44,
+                            "column": 38
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 44,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 44,
+                        "column": 39
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [],
+                    "loc": {
+                      "start": {
+                        "line": 44,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 44,
+                        "column": 43
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 44,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 44,
+                        "column": 46
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 44,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 47
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 44,
+                "column": 15
+              },
+              "end": {
+                "line": 44,
+                "column": 48
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 44,
+              "column": 5
+            },
+            "end": {
+              "line": 44,
+              "column": 48
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 44,
+          "column": 1
+        },
+        "end": {
+          "line": 44,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple18",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 12
+              }
+            }
+          },
+          "init": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "func2",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 15
+                },
+                "end": {
+                  "line": 45,
+                  "column": 20
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 3,
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 24
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 31
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 33
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 38
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 39
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [],
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 43
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 4,
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 46
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 47
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 50
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 51
+                      }
+                    }
+                  },
+                  {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 57
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 58
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 15
+              },
+              "end": {
+                "line": 45,
+                "column": 59
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 5
+            },
+            "end": {
+              "line": 45,
+              "column": 59
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 45,
+          "column": 1
+        },
+        "end": {
+          "line": 45,
+          "column": 60
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 8
+                },
+                "end": {
+                  "line": 47,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 5
+              },
+              "end": {
+                "line": 47,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "tuple17",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 17
+                },
+                "end": {
+                  "line": 47,
+                  "column": 24
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 47,
+                  "column": 25
+                },
+                "end": {
+                  "line": 47,
+                  "column": 26
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 17
+              },
+              "end": {
+                "line": 47,
+                "column": 27
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 5
+            },
+            "end": {
+              "line": 47,
+              "column": 27
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 47,
+          "column": 1
+        },
+        "end": {
+          "line": 47,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "func2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 48,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 48,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 8
+                },
+                "end": {
+                  "line": 48,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 5
+              },
+              "end": {
+                "line": 48,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "tuple18",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 23
+                },
+                "end": {
+                  "line": 48,
+                  "column": 30
+                }
+              }
+            },
+            "property": {
+              "type": "NumberLiteral",
+              "value": 0,
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 31
+                },
+                "end": {
+                  "line": 48,
+                  "column": 32
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 23
+              },
+              "end": {
+                "line": 48,
+                "column": 33
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 48,
+              "column": 5
+            },
+            "end": {
+              "line": 48,
+              "column": 33
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 48,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 34
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 49,
+              "column": 1
+            },
+            "end": {
+              "line": 49,
+              "column": 2
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 6
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 13
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 20
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 49,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 49,
+                    "column": 21
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [],
+                "loc": {
+                  "start": {
+                    "line": 49,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 49,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 49,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 49,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 49,
+                "column": 3
+              },
+              "end": {
+                "line": 49,
+                "column": 29
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 49,
+            "column": 1
+          },
+          "end": {
+            "line": 49,
+            "column": 30
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 49,
+          "column": 1
+        },
+        "end": {
+          "line": 49,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple19",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 51,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 51,
+                          "column": 22
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 51,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 51,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 51,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 51,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 51,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 51,
+                          "column": 41
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 51,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 51,
+                          "column": 49
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 51,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 51,
+                      "column": 49
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 14
+                },
+                "end": {
+                  "line": 51,
+                  "column": 49
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 51,
+                "column": 5
+              },
+              "end": {
+                "line": 51,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 51,
+              "column": 5
+            },
+            "end": {
+              "line": 51,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 51,
+          "column": 1
+        },
+        "end": {
+          "line": 51,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple20",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 52,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 52,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 52,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 52,
+                      "column": 36
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 48
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 52,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 52,
+                        "column": 38
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 52,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 52,
+                      "column": 49
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 14
+                },
+                "end": {
+                  "line": 52,
+                  "column": 49
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 5
+              },
+              "end": {
+                "line": 52,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 52,
+              "column": 5
+            },
+            "end": {
+              "line": 52,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 52,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple21",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "tuple20",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 53,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 53,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 37
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 44
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 50
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 42
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 41
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 51
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 61
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 52
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 62
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 14
+                },
+                "end": {
+                  "line": 53,
+                  "column": 62
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 5
+              },
+              "end": {
+                "line": 53,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 53,
+              "column": 5
+            },
+            "end": {
+              "line": 53,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 53,
+          "column": 1
+        },
+        "end": {
+          "line": 53,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple22",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 30
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 54,
+                  "column": 14
+                },
+                "end": {
+                  "line": 54,
+                  "column": 30
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 5
+              },
+              "end": {
+                "line": 54,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 54,
+              "column": 5
+            },
+            "end": {
+              "line": 54,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 54,
+          "column": 1
+        },
+        "end": {
+          "line": 54,
+          "column": 31
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple21",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 55,
+              "column": 1
+            },
+            "end": {
+              "line": 55,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple20",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 55,
+              "column": 11
+            },
+            "end": {
+              "line": 55,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 55,
+            "column": 1
+          },
+          "end": {
+            "line": 55,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 55,
+          "column": 1
+        },
+        "end": {
+          "line": 55,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple19",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 1
+            },
+            "end": {
+              "line": 56,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "tuple22",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 11
+            },
+            "end": {
+              "line": 56,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 56,
+            "column": 1
+          },
+          "end": {
+            "line": 56,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 56,
+          "column": 1
+        },
+        "end": {
+          "line": 56,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple23",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 22
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 30
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 38
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 38
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 49
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 57
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 58
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 65
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 58,
+                          "column": 66
+                        },
+                        "end": {
+                          "line": 58,
+                          "column": 73
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 73
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 14
+                },
+                "end": {
+                  "line": 58,
+                  "column": 73
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 5
+              },
+              "end": {
+                "line": 58,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 5
+            },
+            "end": {
+              "line": 58,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 58,
+          "column": 74
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple23",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 1
+            },
+            "end": {
+              "line": 59,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 12
+                },
+                "end": {
+                  "line": 59,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 15
+                },
+                "end": {
+                  "line": 59,
+                  "column": 16
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 3,
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 18
+                },
+                "end": {
+                  "line": 59,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 11
+            },
+            "end": {
+              "line": 59,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 59,
+            "column": 1
+          },
+          "end": {
+            "line": 59,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 59,
+          "column": 1
+        },
+        "end": {
+          "line": 59,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple23",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 1
+            },
+            "end": {
+              "line": 60,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 12
+                },
+                "end": {
+                  "line": 60,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 15
+                },
+                "end": {
+                  "line": 60,
+                  "column": 16
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 3,
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 18
+                },
+                "end": {
+                  "line": 60,
+                  "column": 19
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 21
+                },
+                "end": {
+                  "line": 60,
+                  "column": 22
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 11
+            },
+            "end": {
+              "line": 60,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 60,
+            "column": 1
+          },
+          "end": {
+            "line": 60,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 60,
+          "column": 1
+        },
+        "end": {
+          "line": 60,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple24",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 62,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 62,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 62,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 62,
+                          "column": 33
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 62,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 62,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 37
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSTupleType",
+                      "elementTypes": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 62,
+                              "column": 42
+                            },
+                            "end": {
+                              "line": 62,
+                              "column": 49
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 62,
+                              "column": 50
+                            },
+                            "end": {
+                              "line": 62,
+                              "column": 57
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 62,
+                          "column": 41
+                        },
+                        "end": {
+                          "line": 62,
+                          "column": 58
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTupleType",
+                      "elementTypes": [
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 62,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 62,
+                              "column": 67
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 62,
+                              "column": 68
+                            },
+                            "end": {
+                              "line": 62,
+                              "column": 75
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 62,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 62,
+                          "column": 76
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 62,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 62,
+                      "column": 76
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 14
+                },
+                "end": {
+                  "line": 62,
+                  "column": 76
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 62,
+                "column": 5
+              },
+              "end": {
+                "line": 62,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 62,
+              "column": 5
+            },
+            "end": {
+              "line": 62,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 62,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 77
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple24",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 1
+            },
+            "end": {
+              "line": 63,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 3,
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 20
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 12
+                },
+                "end": {
+                  "line": 63,
+                  "column": 21
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 11
+            },
+            "end": {
+              "line": 63,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 63,
+            "column": 1
+          },
+          "end": {
+            "line": 63,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 63,
+          "column": 1
+        },
+        "end": {
+          "line": 63,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple24",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 64,
+              "column": 1
+            },
+            "end": {
+              "line": 64,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 17
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 12
+                },
+                "end": {
+                  "line": 64,
+                  "column": 18
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 26
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 64,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 64,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 20
+                },
+                "end": {
+                  "line": 64,
+                  "column": 34
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 64,
+              "column": 11
+            },
+            "end": {
+              "line": 64,
+              "column": 35
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 1
+          },
+          "end": {
+            "line": 64,
+            "column": 35
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 64,
+          "column": 1
+        },
+        "end": {
+          "line": 64,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple24",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 65,
+              "column": 1
+            },
+            "end": {
+              "line": 65,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 12
+                },
+                "end": {
+                  "line": 65,
+                  "column": 33
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 65,
+              "column": 11
+            },
+            "end": {
+              "line": 65,
+              "column": 34
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 65,
+            "column": 1
+          },
+          "end": {
+            "line": 65,
+            "column": 34
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 65,
+          "column": 1
+        },
+        "end": {
+          "line": 65,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "tuple25",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 67,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 67,
+                          "column": 33
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 67,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 67,
+                          "column": 41
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 50
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 14
+                },
+                "end": {
+                  "line": 67,
+                  "column": 50
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 67,
+                "column": 5
+              },
+              "end": {
+                "line": 67,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 67,
+              "column": 5
+            },
+            "end": {
+              "line": 67,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 67,
+          "column": 1
+        },
+        "end": {
+          "line": 67,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple25",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 68,
+              "column": 1
+            },
+            "end": {
+              "line": 68,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 12
+                },
+                "end": {
+                  "line": 68,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 15
+                },
+                "end": {
+                  "line": 68,
+                  "column": 16
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 3,
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 18
+                },
+                "end": {
+                  "line": 68,
+                  "column": 19
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 21
+                },
+                "end": {
+                  "line": 68,
+                  "column": 22
+                }
+              }
+            },
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 68,
+                  "column": 24
+                },
+                "end": {
+                  "line": 68,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 68,
+              "column": 11
+            },
+            "end": {
+              "line": 68,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 68,
+            "column": 1
+          },
+          "end": {
+            "line": 68,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 68,
+          "column": 1
+        },
+        "end": {
+          "line": 68,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple25",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 69,
+              "column": 1
+            },
+            "end": {
+              "line": 69,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 12
+                },
+                "end": {
+                  "line": 69,
+                  "column": 17
+                }
+              }
+            },
+            {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 19
+                },
+                "end": {
+                  "line": 69,
+                  "column": 24
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 69,
+              "column": 11
+            },
+            "end": {
+              "line": 69,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 69,
+            "column": 1
+          },
+          "end": {
+            "line": 69,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 69,
+          "column": 1
+        },
+        "end": {
+          "line": 69,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "tuple25",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 70,
+              "column": 1
+            },
+            "end": {
+              "line": 70,
+              "column": 8
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 70,
+              "column": 11
+            },
+            "end": {
+              "line": 70,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 70,
+            "column": 1
+          },
+          "end": {
+            "line": 70,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 70,
+          "column": 1
+        },
+        "end": {
+          "line": 70,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 70,
+      "column": 14
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/tupleAssignability.ts b/es2panda/test/compiler/ts/tupleAssignability.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6f78dcce12e292962e9ca54e4706e11a7db6f25f
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability.ts
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var tuple1: [] = [];
+var tuple2: [[[]]] = [[[]]];
+var tuple3: [number, number, number] = [1, 2, 3];
+var tuple4: [typeof tuple1, string] = [[], "foo"];
+var tuple5: [[a: number, b?: string], [boolean | string, number[]]] = [[1], ["foo", [1, 2, 3]]];
+
+var tuple6: [number] | [string] = [5];
+var tuple7: [number, string] | number | string = [5, "foo"];
+var tuple8: (boolean | { a: number, b: string })[] | [string, number | string] = [false, { a: 5, b: "foo" }];
+
+var tuple9: [number, string | number, boolean | string];
+var tuple10: [number, string, string];
+var tuple11: [a: number, b: number | string, c: boolean];
+var tuple12: [a: number, b: string, c: boolean, d?: any];
+var tuple13: [a?: number, b?: number, c?: number];
+
+tuple9 = tuple10;
+tuple9 = tuple11;
+tuple9 = tuple12;
+tuple11 = tuple12;
+tuple13 = tuple1;
+tuple13 = tuple13;
+tuple12 = [1, "foo", true, 5, 6] as [a: number, b: string, c: boolean, d: number, e?: number];
+
+var tuple14 = [[1, 2], func1(1, "foo"), true] as [a?: [number, number], b?: [a: number, b?: boolean[]], c?: boolean];
+tuple14 = [];
+tuple14 = [[1, 2]];
+tuple14 = [[3, 4], [5]];
+tuple14 = [[6, 7], [8, [true, false]]];
+tuple14 = [[9, 10], [11, [true, false]], true];
+
+function func1(a: number, b: string): [a: number, b?: boolean[]] {
+    let tuple15: [number];
+    tuple15 = [123];
+    return tuple15;
+}
+
+var tuple16: [typeof tuple10, typeof tuple1, number];
+
+function func2(a: typeof tuple16, b?: [number, boolean]): [typeof func2, string] {
+    return [func2, "foo"];
+}
+
+var tuple17 = func2([[1, "foo", "bar"], [], 2]);
+var tuple18 = func2([[3, "baz", "qux"], [], 4], [5, true]);
+
+var a: string = tuple17[1];
+var b: typeof func2 = tuple18[0];
+b([[1, "foo", "bar"], [], 2]);
+
+var tuple19: [number, string] | [number, string];
+var tuple20: [a: string, b: number, c?: boolean];
+var tuple21: number | typeof tuple20 | [a: string, b: number];
+var tuple22: [number, string];
+tuple21 = tuple20;
+tuple19 = tuple22;
+
+var tuple23: [number, number, number] | [number, number, number, number];
+tuple23 = [1, 2, 3];
+tuple23 = [1, 2, 3, 4];
+
+var tuple24: number[][] | string[][] | [[number, number], [string, string]];
+tuple24 = [[1, 2, 3]];
+tuple24 = [[1, 2], ["foo", "bar"]];
+tuple24 = [["foo", "bar", "baz"]];
+
+var tuple25: number[] | [string, string] | number;
+tuple25 = [1, 2, 3, 4, 5];
+tuple25 = ["foo", "bar"];
+tuple25 = 12;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability1-expected.txt b/es2panda/test/compiler/ts/tupleAssignability1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a27179a1b9ae32fbd51ed275bf58e9989b8980a
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability1-expected.txt
@@ -0,0 +1,103 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 10
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 15
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 13
+              },
+              "end": {
+                "line": 1,
+                "column": 16
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 16
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 17
+    }
+  }
+}
+TypeError: Type '[number]' is not assignable to type '[]'. [tupleAssignability1.ts:1:5]
diff --git a/es2panda/test/compiler/ts/tupleAssignability1.ts b/es2panda/test/compiler/ts/tupleAssignability1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bbddaca11d3d60c0b9688771716f91e4f95d23a8
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [] = [1];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability10-expected.txt b/es2panda/test/compiler/ts/tupleAssignability10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e355e0ffce18fc45cd90a69138871f2acb3efb5c
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability10-expected.txt
@@ -0,0 +1,173 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 16
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 24
+                },
+                "end": {
+                  "line": 1,
+                  "column": 31
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 15
+            },
+            "end": {
+              "line": 1,
+              "column": 31
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 18
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 27
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 32
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [tupleAssignability10.ts:2:20]
diff --git a/es2panda/test/compiler/ts/tupleAssignability10.ts b/es2panda/test/compiler/ts/tupleAssignability10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8a75aed75512dbd73c51fa4a95c834217f113cc8
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function a(): [string, number] {
+    return ["foo", "bar"];
+}
diff --git a/es2panda/test/compiler/ts/tupleAssignability11-expected.txt b/es2panda/test/compiler/ts/tupleAssignability11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..085b265d82a9cf08868242f9555eb14aba4bee02
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability11-expected.txt
@@ -0,0 +1,206 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 10
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 12
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '[[]]' is not assignable to type '[]'. [tupleAssignability11.ts:3:1]
diff --git a/es2panda/test/compiler/ts/tupleAssignability11.ts b/es2panda/test/compiler/ts/tupleAssignability11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c48de9265f4bc478055a9d89d214bbc194b5b5d
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [];
+var b: [[]];
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability12-expected.txt b/es2panda/test/compiler/ts/tupleAssignability12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..88eae023ce438e3607fd13ef5bb1563fbb7c9e6a
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability12-expected.txt
@@ -0,0 +1,481 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 42
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 42
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 43
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 51
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 52
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 52
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 53
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '[a: number, b: string, c: number, d: number]' is not assignable to type '[a: number, b: string, c?: number]'. [tupleAssignability12.ts:3:1]
diff --git a/es2panda/test/compiler/ts/tupleAssignability12.ts b/es2panda/test/compiler/ts/tupleAssignability12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e251c1a776300e9ad35780bbfa0ce8de0733db71
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [a: number, b: string, c?: number];
+var b: [a: number, b: string, c: number, d: number];
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability13-expected.txt b/es2panda/test/compiler/ts/tupleAssignability13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c283e08712ffb3ff81f20f979b7f6d00f330e46
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability13-expected.txt
@@ -0,0 +1,375 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 40
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 47
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 35
+              },
+              "end": {
+                "line": 1,
+                "column": 48
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 48
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 15
+                },
+                "end": {
+                  "line": 3,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 12
+              },
+              "end": {
+                "line": 3,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 25
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 2
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 5
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 3
+              },
+              "end": {
+                "line": 7,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 14
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [tupleAssignability13.ts:7:10]
diff --git a/es2panda/test/compiler/ts/tupleAssignability13.ts b/es2panda/test/compiler/ts/tupleAssignability13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..658c5f0f2d47c0bd7977dd9ac21824f54335a3b2
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability13.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, number, string] = [1, 2, "foo"];
+
+function b(c: typeof a) {
+
+}
+
+b([1, 2, 3]);
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability14-expected.txt b/es2panda/test/compiler/ts/tupleAssignability14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0e8361e381f44755761b736c07f55229db26a527
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability14-expected.txt
@@ -0,0 +1,88 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 10
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 6,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 13
+              },
+              "end": {
+                "line": 1,
+                "column": 14
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 14
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 15
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type '[]' [tupleAssignability14.ts:1:5]
diff --git a/es2panda/test/compiler/ts/tupleAssignability14.ts b/es2panda/test/compiler/ts/tupleAssignability14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0bdfa24d0feb39f616080a3704d13926df21aff9
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability14.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [] = 6;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability15-expected.txt b/es2panda/test/compiler/ts/tupleAssignability15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..70012730132ffa877e169b534a7e592082c6987d
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability15-expected.txt
@@ -0,0 +1,243 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type 'number[]' is not assignable to type '[number, number, number]'. [tupleAssignability15.ts:3:1]
diff --git a/es2panda/test/compiler/ts/tupleAssignability15.ts b/es2panda/test/compiler/ts/tupleAssignability15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..08aeefba8691979ffff62ef931e3697b36a60826
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability15.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, number, number];
+var b: number[];
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability16-expected.txt b/es2panda/test/compiler/ts/tupleAssignability16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c0f50cd69770e066f05066be2f0eb897544bff06
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability16-expected.txt
@@ -0,0 +1,200 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 28
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 38
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 39
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 47
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 48
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 31
+              },
+              "end": {
+                "line": 1,
+                "column": 49
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 49
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 50
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 50
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [tupleAssignability16.ts:1:33]
diff --git a/es2panda/test/compiler/ts/tupleAssignability16.ts b/es2panda/test/compiler/ts/tupleAssignability16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..452bf1f4b1c8a702bcfb78f277080ab9658328b6
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability16.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number[], string[]] = [["foo"], ["bar"]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability17-expected.txt b/es2panda/test/compiler/ts/tupleAssignability17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f1eaf449aac66b0fa0a7da2605a81c2c6e0c7210
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability17-expected.txt
@@ -0,0 +1,327 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "TSAsExpression",
+          "expression": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 14
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSTupleType",
+            "elementTypes": [
+              {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 26
+                  }
+                }
+              },
+              {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 34
+                  }
+                }
+              },
+              {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 42
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 18
+              },
+              "end": {
+                "line": 3,
+                "column": 42
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 43
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 43
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 43
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 43
+    }
+  }
+}
+TypeError: Type '[number, number, number]' is not assignable to type '[number, string]'. [tupleAssignability17.ts:3:1]
diff --git a/es2panda/test/compiler/ts/tupleAssignability17.ts b/es2panda/test/compiler/ts/tupleAssignability17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2f9d80965ee96b55c1e2e2b90d1f7a51dd7b41c
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability17.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string];
+var b = a;
+b = [1, 2, 3] as [number, number, number];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability18-expected.txt b/es2panda/test/compiler/ts/tupleAssignability18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5791813ac01000153a17753254b6e24778e0f2be
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability18-expected.txt
@@ -0,0 +1,781 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSNamedTupleMember",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 23
+                            }
+                          }
+                        },
+                        "label": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 24
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSNamedTupleMember",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "label": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 2,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 2,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "optional": true,
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 37
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 43
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 49
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 2,
+                                "column": 52
+                              },
+                              "end": {
+                                "line": 2,
+                                "column": 58
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 43
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 59
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 59
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 60
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSTypeQuery",
+                    "exprName": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 72
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 73
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 65
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 73
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 61
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 62
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 61
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 74
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 74
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 79
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 80
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 78
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 81
+                  }
+                }
+              },
+              {
+                "type": "CallExpression",
+                "callee": {
+                  "type": "Identifier",
+                  "name": "func",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 83
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 87
+                    }
+                  }
+                },
+                "arguments": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 88
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 89
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 91
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 96
+                      }
+                    }
+                  }
+                ],
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 83
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 97
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 101
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 102
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 100
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 103
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 99
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 104
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 77
+              },
+              "end": {
+                "line": 2,
+                "column": 105
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 105
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 106
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSTupleType",
+                      "elementTypes": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 18
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 19
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 20
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 10
+            },
+            "end": {
+              "line": 5,
+              "column": 14
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 18
+                },
+                "end": {
+                  "line": 5,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 15
+              },
+              "end": {
+                "line": 5,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 29
+                },
+                "end": {
+                  "line": 5,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 26
+              },
+              "end": {
+                "line": 5,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 39
+                },
+                "end": {
+                  "line": 5,
+                  "column": 46
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 38
+            },
+            "end": {
+              "line": 5,
+              "column": 46
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 14
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 47
+            },
+            "end": {
+              "line": 7,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 2
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type '[number]'. [tupleAssignability18.ts:2:101]
diff --git a/es2panda/test/compiler/ts/tupleAssignability18.ts b/es2panda/test/compiler/ts/tupleAssignability18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e9d49b55f955de1ebbff6a0af2c952c39dd72c6f
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability18.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a: [a?: [a: number, b?: number], b?: [number | string], c?: typeof b] = [[2], func(5, "foo"), [[1]]];
+var b: [[[number]]];
+
+function func(c: number, d: string): [number] {
+    return [1];
+}
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability19-expected.txt b/es2panda/test/compiler/ts/tupleAssignability19-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8cad9ee6d138ed695a14fab0fc26ea6a51b0478e
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability19-expected.txt
@@ -0,0 +1,160 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 27
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 27
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 35
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 30
+              },
+              "end": {
+                "line": 1,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 36
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 37
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 37
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string | number'. [tupleAssignability19.ts:1:31]
diff --git a/es2panda/test/compiler/ts/tupleAssignability19.ts b/es2panda/test/compiler/ts/tupleAssignability19.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a98030b9684fe46e90304358512f7b7f0d93634
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability19.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number] | [string] = [true];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability2-expected.txt b/es2panda/test/compiler/ts/tupleAssignability2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..760c3e08746613c86b8fc4969b4d319e1dc45520
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability2-expected.txt
@@ -0,0 +1,158 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 36
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 6,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 39
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 27
+              },
+              "end": {
+                "line": 1,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 41
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 41
+    }
+  }
+}
+TypeError: Type '[number, string, number]' is not assignable to type '[number, string]'. [tupleAssignability2.ts:1:5]
diff --git a/es2panda/test/compiler/ts/tupleAssignability2.ts b/es2panda/test/compiler/ts/tupleAssignability2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..101f60b79debf13a72452d8651ec3320d25584fa
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string] = [5, "foo", 6];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability20-expected.txt b/es2panda/test/compiler/ts/tupleAssignability20-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ff145bcec969764829bb3013a0ad34f6eb21763
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability20-expected.txt
@@ -0,0 +1,185 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 27
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 35
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 35
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 43
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 46
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 38
+              },
+              "end": {
+                "line": 1,
+                "column": 47
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 47
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 48
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 48
+    }
+  }
+}
+TypeError: Type 'boolean' is not assignable to type 'string | number'. [tupleAssignability20.ts:1:39]
diff --git a/es2panda/test/compiler/ts/tupleAssignability20.ts b/es2panda/test/compiler/ts/tupleAssignability20.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b0aacb845452446966476731a501716a2de57a72
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability20.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[] | [string, number] = [true, 5];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability21-expected.txt b/es2panda/test/compiler/ts/tupleAssignability21-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4b3bb4e328056c2234811ddf89d1699c352bfd43
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability21-expected.txt
@@ -0,0 +1,199 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 36
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 43
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 44
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 51
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 51
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 51
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 56
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 54
+              },
+              "end": {
+                "line": 1,
+                "column": 57
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 57
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 58
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 58
+    }
+  }
+}
+TypeError: Type '[number]' is not assignable to type '[number, number] | [number, number, number]'. [tupleAssignability21.ts:1:5]
diff --git a/es2panda/test/compiler/ts/tupleAssignability21.ts b/es2panda/test/compiler/ts/tupleAssignability21.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f7ac8de5a9381e88b73fc50aac70203f70db191e
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability21.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, number] | [number, number, number] = [1];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability22-expected.txt b/es2panda/test/compiler/ts/tupleAssignability22-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2078f07b58f2569a4277efaabd387c823e656eca
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability22-expected.txt
@@ -0,0 +1,143 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 33
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 36
+              },
+              "end": {
+                "line": 1,
+                "column": 37
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 37
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 38
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 38
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type '[number, number] | string' [tupleAssignability22.ts:1:5]
diff --git a/es2panda/test/compiler/ts/tupleAssignability22.ts b/es2panda/test/compiler/ts/tupleAssignability22.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e50058da7b023f756d89081004ea08d7cfa30887
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability22.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, number] | string = 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability23-expected.txt b/es2panda/test/compiler/ts/tupleAssignability23-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..def872bce54ec6af2bc8b861114e152e4bd3b758
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability23-expected.txt
@@ -0,0 +1,258 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 17
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 25
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 26
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 36
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 43
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 49
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 50
+                      }
+                    }
+                  },
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 52
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 57
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 58
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 61
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 62
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 64
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 65
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 60
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 66
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 47
+              },
+              "end": {
+                "line": 1,
+                "column": 67
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 67
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 68
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 68
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [tupleAssignability23.ts:1:64]
diff --git a/es2panda/test/compiler/ts/tupleAssignability23.ts b/es2panda/test/compiler/ts/tupleAssignability23.ts
new file mode 100644
index 0000000000000000000000000000000000000000..502010b5ef2e44dfa741ebeb510366c610f6a01f
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability23.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [[number, string], [number, string]] = [[1, "foo"], [2, 3]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability24-expected.txt b/es2panda/test/compiler/ts/tupleAssignability24-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ad7bc748200628d77629058240b3ebbc643b78ea
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability24-expected.txt
@@ -0,0 +1,366 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 24
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 43
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 43
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 24
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 32
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 40
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 40
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 51
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 51
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 52
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '[number, number, number, number] | string[]' is not assignable to type '[number, number, number] | number[]'. [tupleAssignability24.ts:3:1]
diff --git a/es2panda/test/compiler/ts/tupleAssignability24.ts b/es2panda/test/compiler/ts/tupleAssignability24.ts
new file mode 100644
index 0000000000000000000000000000000000000000..32915b03d80bb5b2c2dad788a7ccd357cbb979a1
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability24.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, number, number] | number[];
+var b: [number, number, number, number] | string[];
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability3-expected.txt b/es2panda/test/compiler/ts/tupleAssignability3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3f7db01de370b1fbdefba01e9f14346309bf8627
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability3-expected.txt
@@ -0,0 +1,157 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 37
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 40
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 35
+              },
+              "end": {
+                "line": 1,
+                "column": 41
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 41
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 42
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 42
+    }
+  }
+}
+TypeError: Type '[number, number]' is not assignable to type '[number, number, number]'. [tupleAssignability3.ts:1:5]
diff --git a/es2panda/test/compiler/ts/tupleAssignability3.ts b/es2panda/test/compiler/ts/tupleAssignability3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5797724e8897c9268a022648b7a95eeba4f465b4
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, number, number] = [1, 2];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability4-expected.txt b/es2panda/test/compiler/ts/tupleAssignability4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4a81f882dadee0e26a79067e8fc469e61b8a74fc
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability4-expected.txt
@@ -0,0 +1,245 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 7
+    }
+  }
+}
+TypeError: Type '[string, number]' is not assignable to type '[number, string]'. [tupleAssignability4.ts:3:1]
diff --git a/es2panda/test/compiler/ts/tupleAssignability4.ts b/es2panda/test/compiler/ts/tupleAssignability4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c99932842bba0bcb045aaff9f2478206b021d0a4
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string];
+var b: [string, number];
+a = b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability5-expected.txt b/es2panda/test/compiler/ts/tupleAssignability5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..db14b93a524576295bd4f9cf9930882a05e61c5e
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability5-expected.txt
@@ -0,0 +1,144 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 6,
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 32
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 27
+              },
+              "end": {
+                "line": 1,
+                "column": 33
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 33
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 34
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 34
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'string'. [tupleAssignability5.ts:1:31]
diff --git a/es2panda/test/compiler/ts/tupleAssignability5.ts b/es2panda/test/compiler/ts/tupleAssignability5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bc6b4d64f1d473506c1c454e1ea1f7508f688bed
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string] = [5, 6];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability6-expected.txt b/es2panda/test/compiler/ts/tupleAssignability6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d441a705e45df76ba1731acf4d310fd76a4489a
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability6-expected.txt
@@ -0,0 +1,385 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 31
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 35
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 42
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 45
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 51
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 52
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 53
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 53
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 62
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 63
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 63
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 68
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 69
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 67
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 70
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 73
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 78
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 81
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 82
+                          }
+                        }
+                      },
+                      {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 84
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 85
+                          }
+                        }
+                      },
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 87
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 92
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 80
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 93
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 94
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 66
+              },
+              "end": {
+                "line": 1,
+                "column": 95
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 95
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 96
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 96
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [tupleAssignability6.ts:1:87]
diff --git a/es2panda/test/compiler/ts/tupleAssignability6.ts b/es2panda/test/compiler/ts/tupleAssignability6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3acc0d0f509ecfe0f224387cdf9eef23a037a98c
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [[a: number, b?: string], [boolean | string, number[]]] = [[1], ["foo", [1, 2, "foo"]]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability7-expected.txt b/es2panda/test/compiler/ts/tupleAssignability7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..27d7c8ef97ee5340d96ae5141c01a60c3051c735
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability7-expected.txt
@@ -0,0 +1,371 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 31
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSBooleanKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 35
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 42
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 45
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 51
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 52
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 53
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 59
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 53
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 62
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 63
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 63
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 68
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 69
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 67
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 70
+                  }
+                }
+              },
+              {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 73
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 74
+                      }
+                    }
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "NumberLiteral",
+                        "value": 3,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 77
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 78
+                          }
+                        }
+                      },
+                      {
+                        "type": "NumberLiteral",
+                        "value": 4,
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 80
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 81
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 76
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 82
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 72
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 83
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 66
+              },
+              "end": {
+                "line": 1,
+                "column": 84
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 84
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 85
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 85
+    }
+  }
+}
+TypeError: Type 'number' is not assignable to type 'boolean | string'. [tupleAssignability7.ts:1:73]
diff --git a/es2panda/test/compiler/ts/tupleAssignability7.ts b/es2panda/test/compiler/ts/tupleAssignability7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..27b87a69f50db99ed9fd37a57b51f9362870823d
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [[a: number, b?: string], [boolean | string, number[]]] = [[1], [2, [3, 4]]];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability8-expected.txt b/es2panda/test/compiler/ts/tupleAssignability8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8470698c52b8044bce125bed447564e47993f764
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability8-expected.txt
@@ -0,0 +1,458 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 49
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 49
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 53
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 54
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 56
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                },
+                {
+                  "type": "BooleanLiteral",
+                  "value": true,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 63
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 67
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 69
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 70
+                    }
+                  }
+                },
+                {
+                  "type": "NumberLiteral",
+                  "value": 6,
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 72
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 73
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 52
+                },
+                "end": {
+                  "line": 1,
+                  "column": 74
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 82
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 88
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 79
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 80
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 79
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 89
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 93
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 99
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 90
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 91
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 90
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 100
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 104
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 111
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 101
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 102
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 101
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 112
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 116
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 122
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 113
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 114
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 113
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 123
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 127
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 133
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "e",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 124
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 125
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 124
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 134
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 78
+                },
+                "end": {
+                  "line": 1,
+                  "column": 134
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 52
+              },
+              "end": {
+                "line": 1,
+                "column": 135
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 135
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 135
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 135
+    }
+  }
+}
+TypeError: Type '[a: number, b: string, c: boolean, d: number, e: number]' is not assignable to type '[number, string, boolean, number, string]' [tupleAssignability8.ts:1:5]
diff --git a/es2panda/test/compiler/ts/tupleAssignability8.ts b/es2panda/test/compiler/ts/tupleAssignability8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..75b7867602b4277dcf850ea74e2df262fe4cefdd
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability8.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string, boolean, number, string] = [1, "foo", true, 5, 6] as [a: number, b: string, c: boolean, d: number, e: number];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/tupleAssignability9-expected.txt b/es2panda/test/compiler/ts/tupleAssignability9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a7127acf736330be35f6811ebaffca0d7e29bf9d
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability9-expected.txt
@@ -0,0 +1,331 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "returnType": {
+          "type": "TSTupleType",
+          "elementTypes": [
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 23
+                }
+              }
+            },
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 24
+                },
+                "end": {
+                  "line": 3,
+                  "column": 31
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 15
+            },
+            "end": {
+              "line": 3,
+              "column": 31
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "ArrayExpression",
+                "elements": [
+                  {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 18
+                      }
+                    }
+                  },
+                  {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 23
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 32
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "arguments": [],
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 9
+    }
+  }
+}
+TypeError: Type '[string, number]' is not assignable to type '[number, string]'. [tupleAssignability9.ts:7:1]
diff --git a/es2panda/test/compiler/ts/tupleAssignability9.ts b/es2panda/test/compiler/ts/tupleAssignability9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e516a2f260d7bc6c70c89f60764bd9285255dd54
--- /dev/null
+++ b/es2panda/test/compiler/ts/tupleAssignability9.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string];
+
+function b(): [string, number] {
+    return ["foo", 5];
+}
+
+a = b();
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/typeAliasUsedAsValue-expected.txt b/es2panda/test/compiler/ts/typeAliasUsedAsValue-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..303572462a1f8fea7e7e006fe235e894899f7594
--- /dev/null
+++ b/es2panda/test/compiler/ts/typeAliasUsedAsValue-expected.txt
@@ -0,0 +1,371 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSTypeLiteral",
+            "members": [
+              {
+                "type": "TSPropertySignature",
+                "computed": false,
+                "optional": false,
+                "readonly": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 13
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 22
+                  }
+                }
+              },
+              {
+                "type": "TSPropertySignature",
+                "computed": false,
+                "optional": true,
+                "readonly": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 33
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 35
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 10
+              },
+              "end": {
+                "line": 1,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 38
+              },
+              "end": {
+                "line": 1,
+                "column": 44
+              }
+            }
+          },
+          {
+            "type": "TSTupleType",
+            "elementTypes": [
+              {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 55
+                  }
+                }
+              },
+              {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 56
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 63
+                  }
+                }
+              },
+              {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 64
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 71
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 47
+              },
+              "end": {
+                "line": 1,
+                "column": 71
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 10
+          },
+          "end": {
+            "line": 1,
+            "column": 71
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 72
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 71
+        },
+        "end": {
+          "line": 1,
+          "column": 72
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "+=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 1
+            },
+            "end": {
+              "line": 4,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 6
+            },
+            "end": {
+              "line": 4,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 8
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 8
+    }
+  }
+}
+TypeError: a only refers to a type , but is being used as a value here [typeAliasUsedAsValue.ts:4:1]
diff --git a/es2panda/test/compiler/ts/typeAliasUsedAsValue.ts b/es2panda/test/compiler/ts/typeAliasUsedAsValue.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7c60fddcd72677e2b5540564ab12bc66382c66be
--- /dev/null
+++ b/es2panda/test/compiler/ts/typeAliasUsedAsValue.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type a = { a: number, b?: string } | number | [string, string, string];
+var b: a;
+
+a += 2;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/undefined_as_value-expected.txt b/es2panda/test/compiler/ts/undefined_as_value-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..22716265af084e3f6c977533db5be9dc781a5eaf
--- /dev/null
+++ b/es2panda/test/compiler/ts/undefined_as_value-expected.txt
@@ -0,0 +1,495 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUndefinedKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "Identifier",
+            "name": "undefined",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 20
+              },
+              "end": {
+                "line": 1,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 29
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSUndefinedKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 17
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 19
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "undefined",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 32
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "undefined",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 43
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 22
+              },
+              "end": {
+                "line": 2,
+                "column": 44
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 44
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "undefined",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 19
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "undefined",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 30
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "undefined",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 41
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 9
+              },
+              "end": {
+                "line": 3,
+                "column": 42
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 42
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 43
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 10
+            },
+            "end": {
+              "line": 5,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUndefinedKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 17
+                },
+                "end": {
+                  "line": 5,
+                  "column": 26
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 14
+              },
+              "end": {
+                "line": 5,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSUndefinedKeyword",
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 30
+            },
+            "end": {
+              "line": 5,
+              "column": 39
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "Identifier",
+                "name": "undefined",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 3
+                },
+                "end": {
+                  "line": 6,
+                  "column": 20
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 40
+            },
+            "end": {
+              "line": 7,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 1
+            },
+            "end": {
+              "line": 9,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "Identifier",
+            "name": "undefined",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 14
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 1
+          },
+          "end": {
+            "line": 9,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 10,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/undefined_as_value.ts b/es2panda/test/compiler/ts/undefined_as_value.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a581f6c2805f6fc94fc30991f002a2d4637947c
--- /dev/null
+++ b/es2panda/test/compiler/ts/undefined_as_value.ts
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let a: undefined = undefined;
+let b: undefined[] = [undefined, undefined];
+let c = [undefined, undefined, undefined];
+
+function foo(a: undefined) : undefined {
+  return undefined;
+}
+
+foo(undefined);
diff --git a/es2panda/test/compiler/ts/undefined_variable_name-expected.txt b/es2panda/test/compiler/ts/undefined_variable_name-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aeaf6453a2654d79826e1a680fdab9caa572560e
--- /dev/null
+++ b/es2panda/test/compiler/ts/undefined_variable_name-expected.txt
@@ -0,0 +1,216 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "Identifier",
+              "name": "undefined",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 32
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 15
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "right": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 35
+                },
+                "end": {
+                  "line": 1,
+                  "column": 40
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 15
+              },
+              "end": {
+                "line": 1,
+                "column": 40
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSNumberKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 43
+            },
+            "end": {
+              "line": 1,
+              "column": 49
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "Identifier",
+                "name": "undefined",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 22
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 50
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 5,
+              "column": 4
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 7
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 1
+    }
+  }
+}
+TypeError: Type 'string' is not assignable to type 'number'. [undefined_variable_name.ts:2:5]
diff --git a/es2panda/test/compiler/ts/undefined_variable_name.ts b/es2panda/test/compiler/ts/undefined_variable_name.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9e09d47254a682a47a16b9133c37fbe3b7cb627c
--- /dev/null
+++ b/es2panda/test/compiler/ts/undefined_variable_name.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo (undefined: string = "bar"): number {
+    return undefined;
+}
+
+foo();
diff --git a/es2panda/test/compiler/ts/varRedeclaration-expected.txt b/es2panda/test/compiler/ts/varRedeclaration-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..abaf90d0e746bc7f637d629516a881870bc1f108
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration-expected.txt
@@ -0,0 +1,6691 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 23
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 23
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 8
+                },
+                "end": {
+                  "line": 8,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 5
+            },
+            "end": {
+              "line": 11,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSParenthesizedType",
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 13,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 13,
+                                "column": 30
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 13,
+                                "column": 33
+                              },
+                              "end": {
+                                "line": 13,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSVoidKeyword",
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 51
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 8
+                },
+                "end": {
+                  "line": 13,
+                  "column": 51
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 5
+            },
+            "end": {
+              "line": 13,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 52
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSParenthesizedType",
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 14,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 14,
+                                "column": 30
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 14,
+                                "column": 33
+                              },
+                              "end": {
+                                "line": 14,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSVoidKeyword",
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 51
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 8
+                },
+                "end": {
+                  "line": 14,
+                  "column": 51
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 52
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 46
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 48
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 49
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": true,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 51
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 54
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 60
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 62
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 8
+                },
+                "end": {
+                  "line": 16,
+                  "column": 62
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 5
+              },
+              "end": {
+                "line": 16,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 5
+            },
+            "end": {
+              "line": 16,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 38
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 17,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 17,
+                              "column": 46
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 48
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 49
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": true,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 51
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 54
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 60
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 62
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 8
+                },
+                "end": {
+                  "line": 17,
+                  "column": 62
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 5
+                },
+                "end": {
+                  "line": 20,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 8
+                },
+                "end": {
+                  "line": 20,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 5
+                },
+                "end": {
+                  "line": 21,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 8
+                },
+                "end": {
+                  "line": 21,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 22
+          },
+          "end": {
+            "line": 22,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 11
+          },
+          "end": {
+            "line": 19,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 5
+                },
+                "end": {
+                  "line": 25,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 5
+                },
+                "end": {
+                  "line": 26,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 8
+                },
+                "end": {
+                  "line": 26,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 26,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 22
+          },
+          "end": {
+            "line": 27,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 11
+          },
+          "end": {
+            "line": 24,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "g",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 8
+                },
+                "end": {
+                  "line": 29,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 29,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "g",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 8
+                },
+                "end": {
+                  "line": 30,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 5
+              },
+              "end": {
+                "line": 30,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 5
+            },
+            "end": {
+              "line": 30,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 5
+                },
+                "end": {
+                  "line": 33,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 8
+                },
+                "end": {
+                  "line": 33,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 41
+          },
+          "end": {
+            "line": 34,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 11
+          },
+          "end": {
+            "line": 32,
+            "column": 21
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "interface1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 30
+              },
+              "end": {
+                "line": 32,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 41
+            },
+            "end": {
+              "line": 32,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 5
+                },
+                "end": {
+                  "line": 37,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 8
+                },
+                "end": {
+                  "line": 37,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 5
+              },
+              "end": {
+                "line": 37,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 41
+          },
+          "end": {
+            "line": 38,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 11
+          },
+          "end": {
+            "line": 36,
+            "column": 21
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "interface2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 30
+              },
+              "end": {
+                "line": 36,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 41
+            },
+            "end": {
+              "line": 36,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "h",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface3",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 8
+                },
+                "end": {
+                  "line": 40,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 5
+              },
+              "end": {
+                "line": 40,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 5
+            },
+            "end": {
+              "line": 40,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "h",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface4",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 8
+                },
+                "end": {
+                  "line": 41,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 5
+              },
+              "end": {
+                "line": 41,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 5
+            },
+            "end": {
+              "line": 41,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 44,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 44,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 44,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 44,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 44,
+                "column": 5
+              },
+              "end": {
+                "line": 44,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 46,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 46,
+                      "column": 20
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 28
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 37
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 49
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 46,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 46,
+                      "column": 49
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 46,
+                "column": 5
+              },
+              "end": {
+                "line": 46,
+                "column": 51
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 47,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 47,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 47,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 47,
+                      "column": 20
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 47,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 47,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 47,
+                            "column": 28
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 47,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 47,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 47,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 47,
+                          "column": 37
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 47,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 47,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 47,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 47,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 47,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 47,
+                          "column": 49
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 47,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 47,
+                      "column": 49
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 47,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 47,
+                "column": 5
+              },
+              "end": {
+                "line": 47,
+                "column": 51
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 43,
+            "column": 22
+          },
+          "end": {
+            "line": 48,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface5",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 43,
+            "column": 11
+          },
+          "end": {
+            "line": 43,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 43,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 51,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 51,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 51,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 51,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 51,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 51,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 51,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 51,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 51,
+                "column": 5
+              },
+              "end": {
+                "line": 51,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 52,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 52,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 52,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 52,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 5
+              },
+              "end": {
+                "line": 52,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 53,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 53,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 20
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 28
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 37
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 49
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 49
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 5
+              },
+              "end": {
+                "line": 53,
+                "column": 51
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 54,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 54,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 20
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 54,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 54,
+                            "column": 28
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 54,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 54,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 54,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 54,
+                          "column": 37
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 54,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 54,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 54,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 54,
+                            "column": 47
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 54,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 54,
+                          "column": 49
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 49
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 23
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 5
+              },
+              "end": {
+                "line": 54,
+                "column": 51
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 22
+          },
+          "end": {
+            "line": 55,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface6",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 11
+          },
+          "end": {
+            "line": 50,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 55,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "i",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface5",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 8
+                },
+                "end": {
+                  "line": 57,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 57,
+                "column": 5
+              },
+              "end": {
+                "line": 57,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 5
+            },
+            "end": {
+              "line": 57,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 57,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "i",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface6",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 8
+                },
+                "end": {
+                  "line": 58,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 5
+              },
+              "end": {
+                "line": 58,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 5
+            },
+            "end": {
+              "line": 58,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 58,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "j",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 60,
+                "column": 5
+              },
+              "end": {
+                "line": 60,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "interface6",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 60,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 60,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 60,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 60,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 60,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 60,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 60,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 60,
+                          "column": 43
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 60,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 60,
+                        "column": 45
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 60,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 60,
+                      "column": 35
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 54
+                  }
+                }
+              },
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "ReturnStatement",
+                    "argument": {
+                      "type": "NumberLiteral",
+                      "value": 123,
+                      "loc": {
+                        "start": {
+                          "line": 61,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 61,
+                          "column": 15
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 61,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 61,
+                        "column": 16
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 62,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 9
+                },
+                "end": {
+                  "line": 62,
+                  "column": 2
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 60,
+                "column": 9
+              },
+              "end": {
+                "line": 62,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 60,
+              "column": 5
+            },
+            "end": {
+              "line": 62,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 60,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "j",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "interface6",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 63,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 63,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 63,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 63,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 63,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 63,
+                          "column": 33
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 63,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 63,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 63,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 63,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 63,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 63,
+                    "column": 46
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 8
+                },
+                "end": {
+                  "line": 63,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 63,
+                "column": 5
+              },
+              "end": {
+                "line": 63,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 5
+            },
+            "end": {
+              "line": 63,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 63,
+          "column": 1
+        },
+        "end": {
+          "line": 63,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "obj",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 65,
+                "column": 5
+              },
+              "end": {
+                "line": 65,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 14
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 17
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 65,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 65,
+                    "column": 17
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 20
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 23
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 65,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 65,
+                    "column": 23
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 26
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 3,
+                  "loc": {
+                    "start": {
+                      "line": 65,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 65,
+                      "column": 29
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 65,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 65,
+                    "column": 29
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 65,
+                "column": 11
+              },
+              "end": {
+                "line": 65,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 65,
+              "column": 5
+            },
+            "end": {
+              "line": 65,
+              "column": 31
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 65,
+          "column": 1
+        },
+        "end": {
+          "line": 65,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "k",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 66,
+                "column": 5
+              },
+              "end": {
+                "line": 66,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 12
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 19
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 66,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 66,
+                    "column": 19
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "e",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 22
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 29
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 66,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 66,
+                    "column": 29
+                  }
+                }
+              },
+              {
+                "type": "SpreadElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "obj",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 37
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 66,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 66,
+                    "column": 37
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 66,
+                "column": 9
+              },
+              "end": {
+                "line": 66,
+                "column": 39
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 66,
+              "column": 5
+            },
+            "end": {
+              "line": 66,
+              "column": 39
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 66,
+          "column": 1
+        },
+        "end": {
+          "line": 66,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "k",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 42
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 53
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "e",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 55
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 67,
+                        "column": 57
+                      },
+                      "end": {
+                        "line": 67,
+                        "column": 63
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 67,
+                      "column": 54
+                    },
+                    "end": {
+                      "line": 67,
+                      "column": 65
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 67,
+                  "column": 8
+                },
+                "end": {
+                  "line": 67,
+                  "column": 65
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 67,
+                "column": 5
+              },
+              "end": {
+                "line": 67,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 67,
+              "column": 5
+            },
+            "end": {
+              "line": 67,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 67,
+          "column": 1
+        },
+        "end": {
+          "line": 67,
+          "column": 66
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 69,
+              "column": 10
+            },
+            "end": {
+              "line": 69,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 19
+                },
+                "end": {
+                  "line": 69,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 16
+              },
+              "end": {
+                "line": 69,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 69,
+                  "column": 30
+                },
+                "end": {
+                  "line": 69,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 27
+              },
+              "end": {
+                "line": 69,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSLiteralType",
+          "literal": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 69,
+                "column": 39
+              },
+              "end": {
+                "line": 69,
+                "column": 44
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 69,
+              "column": 39
+            },
+            "end": {
+              "line": 69,
+              "column": 44
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 70,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 70,
+                    "column": 17
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 70,
+                  "column": 5
+                },
+                "end": {
+                  "line": 70,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 69,
+              "column": 45
+            },
+            "end": {
+              "line": 71,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 69,
+            "column": 1
+          },
+          "end": {
+            "line": 71,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 69,
+          "column": 1
+        },
+        "end": {
+          "line": 71,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 72,
+              "column": 10
+            },
+            "end": {
+              "line": 72,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 72,
+                  "column": 19
+                },
+                "end": {
+                  "line": 72,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 16
+              },
+              "end": {
+                "line": 72,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 72,
+                  "column": 30
+                },
+                "end": {
+                  "line": 72,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 27
+              },
+              "end": {
+                "line": 72,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSLiteralType",
+          "literal": {
+            "type": "BooleanLiteral",
+            "value": true,
+            "loc": {
+              "start": {
+                "line": 72,
+                "column": 39
+              },
+              "end": {
+                "line": 72,
+                "column": 43
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 72,
+              "column": 39
+            },
+            "end": {
+              "line": 72,
+              "column": 43
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 73,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 73,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 73,
+                  "column": 5
+                },
+                "end": {
+                  "line": 73,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 72,
+              "column": 44
+            },
+            "end": {
+              "line": 74,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 72,
+            "column": 1
+          },
+          "end": {
+            "line": 74,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 72,
+          "column": 1
+        },
+        "end": {
+          "line": 74,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "l",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "func1",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 75,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 75,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 75,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 75,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "func2",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 75,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 75,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 75,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 75,
+                      "column": 35
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 75,
+                  "column": 8
+                },
+                "end": {
+                  "line": 75,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 75,
+                "column": 5
+              },
+              "end": {
+                "line": 75,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 75,
+              "column": 5
+            },
+            "end": {
+              "line": 75,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 75,
+          "column": 1
+        },
+        "end": {
+          "line": 75,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "l",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSParenthesizedType",
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 76,
+                              "column": 13
+                            },
+                            "end": {
+                              "line": 76,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 76,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 76,
+                            "column": 11
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 76,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 76,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 76,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 76,
+                            "column": 22
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 76,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 76,
+                            "column": 40
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 76,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 76,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 76,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 76,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 76,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 76,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSParenthesizedType",
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 76,
+                              "column": 49
+                            },
+                            "end": {
+                              "line": 76,
+                              "column": 55
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 76,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 76,
+                            "column": 47
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 76,
+                              "column": 60
+                            },
+                            "end": {
+                              "line": 76,
+                              "column": 66
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 76,
+                            "column": 57
+                          },
+                          "end": {
+                            "line": 76,
+                            "column": 58
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 76,
+                            "column": 71
+                          },
+                          "end": {
+                            "line": 76,
+                            "column": 75
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 76,
+                          "column": 71
+                        },
+                        "end": {
+                          "line": 76,
+                          "column": 75
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 76,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 76,
+                        "column": 75
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 76,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 76,
+                      "column": 76
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 76,
+                  "column": 8
+                },
+                "end": {
+                  "line": 76,
+                  "column": 76
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 76,
+                "column": 5
+              },
+              "end": {
+                "line": 76,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 76,
+              "column": 5
+            },
+            "end": {
+              "line": 76,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 76,
+          "column": 1
+        },
+        "end": {
+          "line": 76,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "m",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 78,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 78,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 78,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 78,
+                      "column": 42
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 78,
+                  "column": 8
+                },
+                "end": {
+                  "line": 78,
+                  "column": 42
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 78,
+                "column": 5
+              },
+              "end": {
+                "line": 78,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 78,
+              "column": 5
+            },
+            "end": {
+              "line": 78,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 78,
+          "column": 1
+        },
+        "end": {
+          "line": 78,
+          "column": 43
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "m",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 79,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 79,
+                      "column": 33
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 79,
+                  "column": 8
+                },
+                "end": {
+                  "line": 79,
+                  "column": 33
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 79,
+                "column": 5
+              },
+              "end": {
+                "line": 79,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 79,
+              "column": 5
+            },
+            "end": {
+              "line": 79,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 79,
+          "column": 1
+        },
+        "end": {
+          "line": 79,
+          "column": 34
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "n",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 81,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 81,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 81,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 81,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 81,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 81,
+                            "column": 21
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 81,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 81,
+                          "column": 22
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 81,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 81,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 81,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 81,
+                          "column": 25
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "NumberLiteral",
+                        "value": 3,
+                        "loc": {
+                          "start": {
+                            "line": 81,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 81,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 81,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 81,
+                          "column": 28
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 81,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 81,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 81,
+                  "column": 8
+                },
+                "end": {
+                  "line": 81,
+                  "column": 28
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 81,
+                "column": 5
+              },
+              "end": {
+                "line": 81,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 81,
+              "column": 5
+            },
+            "end": {
+              "line": 81,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 81,
+          "column": 1
+        },
+        "end": {
+          "line": 81,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "n",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 82,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 82,
+                            "column": 10
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 82,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 82,
+                          "column": 11
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 82,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 82,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 82,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 82,
+                          "column": 14
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "NumberLiteral",
+                        "value": 3,
+                        "loc": {
+                          "start": {
+                            "line": 82,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 82,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 82,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 82,
+                          "column": 17
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 82,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 82,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 82,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 82,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 82,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 82,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 82,
+                  "column": 8
+                },
+                "end": {
+                  "line": 82,
+                  "column": 28
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 82,
+                "column": 5
+              },
+              "end": {
+                "line": 82,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 82,
+              "column": 5
+            },
+            "end": {
+              "line": 82,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 82,
+          "column": 1
+        },
+        "end": {
+          "line": 82,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 85,
+                  "column": 5
+                },
+                "end": {
+                  "line": 85,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 85,
+                  "column": 8
+                },
+                "end": {
+                  "line": 85,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 85,
+                "column": 5
+              },
+              "end": {
+                "line": 85,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 84,
+            "column": 22
+          },
+          "end": {
+            "line": 86,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface7",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 84,
+            "column": 11
+          },
+          "end": {
+            "line": 84,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 84,
+          "column": 1
+        },
+        "end": {
+          "line": 86,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 89,
+                  "column": 5
+                },
+                "end": {
+                  "line": 89,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 89,
+                  "column": 8
+                },
+                "end": {
+                  "line": 89,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 89,
+                "column": 5
+              },
+              "end": {
+                "line": 89,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 88,
+            "column": 41
+          },
+          "end": {
+            "line": 90,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface8",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 88,
+            "column": 11
+          },
+          "end": {
+            "line": 88,
+            "column": 21
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "interface7",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 88,
+                "column": 30
+              },
+              "end": {
+                "line": 88,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 88,
+              "column": 41
+            },
+            "end": {
+              "line": 88,
+              "column": 40
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 88,
+          "column": 1
+        },
+        "end": {
+          "line": 90,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 93,
+                  "column": 5
+                },
+                "end": {
+                  "line": 93,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 93,
+                  "column": 8
+                },
+                "end": {
+                  "line": 93,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 93,
+                "column": 5
+              },
+              "end": {
+                "line": 93,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 92,
+            "column": 22
+          },
+          "end": {
+            "line": 94,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "interface9",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 92,
+            "column": 11
+          },
+          "end": {
+            "line": 92,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 92,
+          "column": 1
+        },
+        "end": {
+          "line": 94,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface9",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 96,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 96,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 96,
+                  "column": 8
+                },
+                "end": {
+                  "line": 96,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 96,
+                "column": 5
+              },
+              "end": {
+                "line": 96,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 96,
+              "column": 5
+            },
+            "end": {
+              "line": 96,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 96,
+          "column": 1
+        },
+        "end": {
+          "line": 96,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "interface8",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 97,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 97,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 97,
+                  "column": 8
+                },
+                "end": {
+                  "line": 97,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 97,
+                "column": 5
+              },
+              "end": {
+                "line": 97,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 97,
+              "column": 5
+            },
+            "end": {
+              "line": 97,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 97,
+          "column": 1
+        },
+        "end": {
+          "line": 97,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "p",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 99,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 99,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 99,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 99,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 99,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 99,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 99,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 99,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 99,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 99,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 99,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 99,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 99,
+                  "column": 8
+                },
+                "end": {
+                  "line": 99,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 99,
+                "column": 5
+              },
+              "end": {
+                "line": 99,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 99,
+              "column": 5
+            },
+            "end": {
+              "line": 99,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 99,
+          "column": 1
+        },
+        "end": {
+          "line": 99,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "p",
+            "typeAnnotation": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "p",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 100,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 100,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 100,
+                  "column": 8
+                },
+                "end": {
+                  "line": 100,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 100,
+                "column": 5
+              },
+              "end": {
+                "line": 100,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 100,
+              "column": 5
+            },
+            "end": {
+              "line": 100,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 100,
+          "column": 1
+        },
+        "end": {
+          "line": 100,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 100,
+      "column": 17
+    }
+  }
+}
diff --git a/es2panda/test/compiler/ts/varRedeclaration.ts b/es2panda/test/compiler/ts/varRedeclaration.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b9c8f12d91e84dee7d93f8fda8221b29d9db194e
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration.ts
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a;
+var a;
+
+var b: number;
+var b: number;
+
+var c: number | string;
+var c: string | number;
+
+var d: { a: number, b: string };
+var d: { b: string, a: number };
+
+var e: (a: number, b: (string | number)[]) => void;
+var e: (a: number, b: (string | number)[]) => void;
+
+var f: { a: number, b: string } | { a: number[], b?: string };
+var f: { a: number, b: string } | { a: number[], b?: string };
+
+interface interface1 {
+    a: number,
+    b: string,
+}
+
+interface interface2 {
+    a: number,
+    b: string,
+}
+
+var g: interface1;
+var g: interface2;
+
+interface interface3 extends interface1 {
+    c: boolean,
+}
+
+interface interface4 extends interface2 {
+    c: boolean,
+}
+
+var h: interface3;
+var h: interface4;
+
+interface interface5 {
+    (a: number, b: string),
+    (a: number, b: string),
+    new(a: number[], b: { a: number, b: string }),
+    new(a: number[], b: { a: number, b: string }),
+}
+
+interface interface6 {
+    (a: number, b: string),
+    (a: number, b: string),
+    new(a: number[], b: { a: number, b: string }),
+    new(a: number[], b: { a: number, b: string }),
+}
+
+var i: interface5;
+var i: interface6;
+
+var j = function (a: interface6, b: number[]): number {
+    return 123;
+}
+var j: (a: interface6, b: number[]) => number;
+
+var obj = { a: 1, b: 2, c: 3 };
+var k = { d: "foo", e: "bar", ...obj };
+var k: { a: number, b: number, c: number, d: string, e: string };
+
+function func1(a: number, b: string): "foo" {
+    return "foo";
+}
+function func2(a: string, b: number): true {
+    return true;
+}
+var l: typeof func1 | typeof func2;
+var l: ((a: number, b: string) => "foo") | ((a: string, b: number) => true)
+
+var m: [a: number, b: string, c: boolean];
+var m: [number, string, boolean];
+
+var n: number[] | [1, 2, 3];
+var n: [1, 2, 3] | number[];
+
+interface interface7 {
+    a: number,
+}
+
+interface interface8 extends interface7 {
+    a: number,
+}
+
+interface interface9 {
+    a: number;
+}
+
+var o: interface9;
+var o: interface8;
+
+var p: { a: number, b: string };
+var p: typeof p;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration1-expected.txt b/es2panda/test/compiler/ts/varRedeclaration1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..78610e7aaae3b17c6a8ac958c0b8f836c03fbbd5
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration1-expected.txt
@@ -0,0 +1,119 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 15
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type 'any', but here has type 'number'. [varRedeclaration1.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration1.ts b/es2panda/test/compiler/ts/varRedeclaration1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..823dc22a18e7ab894585e02504b91c63ed87125f
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration1.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a;
+var a: number;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration10-expected.txt b/es2panda/test/compiler/ts/varRedeclaration10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6944edd94a0def6eded0451499776ec77aa74599
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration10-expected.txt
@@ -0,0 +1,44 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 3
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 3
+    }
+  }
+}
+TypeError: Cannot find name a [varRedeclaration10.ts:6:1]
diff --git a/es2panda/test/compiler/ts/varRedeclaration10.ts b/es2panda/test/compiler/ts/varRedeclaration10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f52767007beeea07a6ccaa6dab0d21b78081c9f4
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration10.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*
+TODO: this test is disabled because it is not comaptible with the current implementation of the destructuring yet
+var a: {}
+var a: { a?: number }
+*/
+a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration11-expected.txt b/es2panda/test/compiler/ts/varRedeclaration11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3c9a6156c1455c9d40e8307fbc35348124a2eed6
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration11-expected.txt
@@ -0,0 +1,396 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 25
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 37
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 37
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 46
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeLiteral",
+                  "members": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 46
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 47
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 47
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type '{ } | { a: number; b: string; } | number', but here has type '{ a: number; b: string; } | string | { }'. [varRedeclaration11.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration11.ts b/es2panda/test/compiler/ts/varRedeclaration11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6a56695c6e497871734cbc89c007b59a630f3bef
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration11.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: {} | { a: number, b: string } | number;
+var a: { a: number, b: string } | string | {};
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration12-expected.txt b/es2panda/test/compiler/ts/varRedeclaration12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..487aa7ed838d57dbd79cbc2cbcfecdf588168c8b
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration12-expected.txt
@@ -0,0 +1,502 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 29
+                },
+                "end": {
+                  "line": 2,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 36
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 29
+                },
+                "end": {
+                  "line": 3,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 4,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 26
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 29
+                },
+                "end": {
+                  "line": 7,
+                  "column": 35
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 13
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 5
+            },
+            "end": {
+              "line": 11,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 11,
+      "column": 10
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'c' must be of type 'a', but here has type 'b'. [varRedeclaration12.ts:11:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration12.ts b/es2panda/test/compiler/ts/varRedeclaration12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..591ed6b443cd108fe1c8ffd617c8ea4b1db8a3f3
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration12.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    (a: number, b: string): number,
+    (a: number, b: string): number,
+}
+
+interface b {
+    (a: number, b: string): number,
+}
+
+var c: a;
+var c: b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration13-expected.txt b/es2panda/test/compiler/ts/varRedeclaration13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1d79dbe98542e8aa3eb8844e91fbd34b7dc81467
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration13-expected.txt
@@ -0,0 +1,735 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 18
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 29
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 32
+                },
+                "end": {
+                  "line": 6,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 13
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 18
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 29
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 32
+                },
+                "end": {
+                  "line": 10,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 26
+          },
+          "end": {
+            "line": 11,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "c",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 11
+          },
+          "end": {
+            "line": 9,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 21
+              },
+              "end": {
+                "line": 9,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 22
+            },
+            "end": {
+              "line": 9,
+              "column": 22
+            }
+          }
+        },
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 24
+              },
+              "end": {
+                "line": 9,
+                "column": 25
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 26
+            },
+            "end": {
+              "line": 9,
+              "column": 25
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 5
+                },
+                "end": {
+                  "line": 14,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 8
+                },
+                "end": {
+                  "line": 14,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 18
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 29
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 32
+                },
+                "end": {
+                  "line": 15,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 16,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 13
+          },
+          "end": {
+            "line": 16,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "d",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 11
+          },
+          "end": {
+            "line": 13,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 8
+                },
+                "end": {
+                  "line": 18,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 5
+              },
+              "end": {
+                "line": 18,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 5
+            },
+            "end": {
+              "line": 18,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 8
+                },
+                "end": {
+                  "line": 19,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 5
+              },
+              "end": {
+                "line": 19,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 5
+            },
+            "end": {
+              "line": 19,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 19,
+      "column": 10
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type 'd', but here has type 'c'. [varRedeclaration13.ts:19:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration13.ts b/es2panda/test/compiler/ts/varRedeclaration13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a2215161e669af2518c946289135fd8f3577c752
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration13.ts
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: number
+}
+
+interface b {
+    new(a: number, b: string): number
+}
+
+interface c extends a, b {
+    new(a: number, b: string): number
+}
+
+interface d {
+    a: number,
+    new(a: number, b: string): number
+}
+
+var a: d;
+var a: c;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration14-expected.txt b/es2panda/test/compiler/ts/varRedeclaration14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cad9a1a53a0950f96ef76da08180231704a54af3
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration14-expected.txt
@@ -0,0 +1,483 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 23
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 21
+              },
+              "end": {
+                "line": 5,
+                "column": 22
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 23
+            },
+            "end": {
+              "line": 5,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 5
+                },
+                "end": {
+                  "line": 10,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 23
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 13
+          },
+          "end": {
+            "line": 11,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "c",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 11
+          },
+          "end": {
+            "line": 9,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 8
+                },
+                "end": {
+                  "line": 13,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 13,
+              "column": 5
+            },
+            "end": {
+              "line": 13,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 13,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 8
+                },
+                "end": {
+                  "line": 14,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 14,
+      "column": 10
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type 'c', but here has type 'b'. [varRedeclaration14.ts:14:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration14.ts b/es2panda/test/compiler/ts/varRedeclaration14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2c16ec588448ecf0409a2460b66a032bc1889b1a
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration14.ts
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface a {
+    a: number,
+}
+
+interface b extends a {
+    a: number,
+}
+
+interface c {
+    a: number | string;
+}
+
+var a: c;
+var a: b;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration15-expected.txt b/es2panda/test/compiler/ts/varRedeclaration15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1b40f7035cfa1d6d58e940c669eaf0fe4df2baf1
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration15-expected.txt
@@ -0,0 +1,279 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 20
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 20
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 21
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type '{ a: number; b: string; }', but here has type '{ a: number; b: string; } | 5'. [varRedeclaration15.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration15.ts b/es2panda/test/compiler/ts/varRedeclaration15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e51d8269d98d5815ff1d1d1d4cc8cdbf68795780
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration15.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a: number, b: string };
+var a: typeof a | 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration2-expected.txt b/es2panda/test/compiler/ts/varRedeclaration2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4356e8b7885c0cc0a82bfad12ef02aed7f2acc5
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration2-expected.txt
@@ -0,0 +1,146 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSLiteralType",
+              "literal": {
+                "type": "NumberLiteral",
+                "value": 5,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 10
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type 'number', but here has type '5'. [varRedeclaration2.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration2.ts b/es2panda/test/compiler/ts/varRedeclaration2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d2d8cb03aa27fa96d333f47d33105bcc54f2539
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration2.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var a: 5;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration3-expected.txt b/es2panda/test/compiler/ts/varRedeclaration3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b14da0ecba65041ba918de804c84bcf308e3f638
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration3-expected.txt
@@ -0,0 +1,160 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 23
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 24
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 24
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type 'number', but here has type 'number | string'. [varRedeclaration3.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration3.ts b/es2panda/test/compiler/ts/varRedeclaration3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fa4da023bee60a69db9909c777e2a590f2eec5e0
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration3.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number;
+var a: number | string;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration4-expected.txt b/es2panda/test/compiler/ts/varRedeclaration4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..470f912694daa5548fc7e76b9a67e3046186d8da
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration4-expected.txt
@@ -0,0 +1,158 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 16
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type 'number[]', but here has type 'string[]'. [varRedeclaration4.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration4.ts b/es2panda/test/compiler/ts/varRedeclaration4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49ddd0a6c8e6d10f340f2e0b5c57a45ac8452aae
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration4.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number[]
+var a: string[]
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration5-expected.txt b/es2panda/test/compiler/ts/varRedeclaration5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..33b47e61d86a46920fd6069d7465edfc882d89c6
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration5-expected.txt
@@ -0,0 +1,44 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 3
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 3
+    }
+  }
+}
+TypeError: Cannot find name a [varRedeclaration5.ts:6:1]
diff --git a/es2panda/test/compiler/ts/varRedeclaration5.ts b/es2panda/test/compiler/ts/varRedeclaration5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3bbffab80742a1b601b4b62e83e60ea08dc70b72
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration5.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*
+TODO: this test is disabled because it is not comaptible with the current implementation of the destructuring yet
+var a: { a: number, b: string };
+var a: { a: string, b: number };
+*/
+a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration6-expected.txt b/es2panda/test/compiler/ts/varRedeclaration6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..251ed286e7f498e2fa34d24207c85c8a1134aa5a
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration6-expected.txt
@@ -0,0 +1,299 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 35
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 42
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 42
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 43
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 43
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type '[number, string, number]', but here has type '[a: number, b: string, c?: number]'. [varRedeclaration6.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration6.ts b/es2panda/test/compiler/ts/varRedeclaration6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..68a8e671b713a30daadd284d1883d0a2f6796bd8
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, string, number];
+var a: [a: number, b: string, c?: number];
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration7-expected.txt b/es2panda/test/compiler/ts/varRedeclaration7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..66b4f4b9523a7a9d32343fa20648493b8a1e2286
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration7-expected.txt
@@ -0,0 +1,44 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 3
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 3
+    }
+  }
+}
+TypeError: Cannot find name a [varRedeclaration7.ts:6:1]
diff --git a/es2panda/test/compiler/ts/varRedeclaration7.ts b/es2panda/test/compiler/ts/varRedeclaration7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8534e3b9f36440b93947c2f0b609988f75d8454b
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration7.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*
+TODO: this test is disabled because it is not comaptible with the current implementation of the destructuring yet
+var a: { a: number, b?: string };
+var a: { a: number, b: string };
+*/
+a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration8-expected.txt b/es2panda/test/compiler/ts/varRedeclaration8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..24c971843d55a8633142aa80a6808b2ec74257aa
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration8-expected.txt
@@ -0,0 +1,44 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 3
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 3
+    }
+  }
+}
+TypeError: Cannot find name a [varRedeclaration8.ts:8:1]
diff --git a/es2panda/test/compiler/ts/varRedeclaration8.ts b/es2panda/test/compiler/ts/varRedeclaration8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d8d2c9fa9978981cefa029295b5e9d558e6c26ff
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration8.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*
+TODO: this test is disabled because it is not comaptible with the current implementation of the destructuring yet
+var b: 5;
+var obj = { a: 1, [b]: 2 };
+var a = { a: "foo", ...obj };
+var a: { a: number, 5: string };
+*/
+a;
\ No newline at end of file
diff --git a/es2panda/test/compiler/ts/varRedeclaration9-expected.txt b/es2panda/test/compiler/ts/varRedeclaration9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..09b12b92abf8d607236982bc1f0b4b7ba6ef2cf1
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration9-expected.txt
@@ -0,0 +1,275 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 41
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 41
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 40
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 40
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 41
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 41
+    }
+  }
+}
+TypeError: Subsequent variable declaration must have the same type. Variable 'a' must be of type '(a: number, b?: number) => number', but here has type '(a: number, b: number) => number'. [varRedeclaration9.ts:2:5]
diff --git a/es2panda/test/compiler/ts/varRedeclaration9.ts b/es2panda/test/compiler/ts/varRedeclaration9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..872639b0d1b9fa0e76166e9e6ba1d43d92452bb1
--- /dev/null
+++ b/es2panda/test/compiler/ts/varRedeclaration9.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: (a: number, b?: number) => number;
+var a: (a: number, b: number) => number;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/invalid-left-hand-side-in-prefix-operation-expected.txt b/es2panda/test/parser/js/invalid-left-hand-side-in-prefix-operation-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a186e9fee6bb0efa71660be7e8113884e0a1514
--- /dev/null
+++ b/es2panda/test/parser/js/invalid-left-hand-side-in-prefix-operation-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Invalid left-hand side in prefix operation [invalid-left-hand-side-in-prefix-operation.js:17:5]
diff --git a/es2panda/test/parser/js/invalid-left-hand-side-in-prefix-operation.js b/es2panda/test/parser/js/invalid-left-hand-side-in-prefix-operation.js
new file mode 100644
index 0000000000000000000000000000000000000000..377ea698e57d460dd2392d88208cf78f5f37fa4f
--- /dev/null
+++ b/es2panda/test/parser/js/invalid-left-hand-side-in-prefix-operation.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+++!a
\ No newline at end of file
diff --git a/es2panda/test/parser/js/new-expression-expected.txt b/es2panda/test/parser/js/new-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f162667d3d335b9cd705c4d087eb8127be57036a
--- /dev/null
+++ b/es2panda/test/parser/js/new-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [new-expression.js:17:8]
diff --git a/es2panda/test/parser/js/new-expression.js b/es2panda/test/parser/js/new-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..d73903bdc5b9090722785a37012eb6d76d42ae22
--- /dev/null
+++ b/es2panda/test/parser/js/new-expression.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+new a(){};
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-array-expression-1-expected.txt b/es2panda/test/parser/js/test-array-expression-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a130bee8241cfc79c458e2519bd86cfd7950ac7f
--- /dev/null
+++ b/es2panda/test/parser/js/test-array-expression-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected ',' or ']' [test-array-expression-1.js:17:8]
diff --git a/es2panda/test/parser/js/test-array-expression-1.js b/es2panda/test/parser/js/test-array-expression-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..e268bb56dc9657d9f47d045a4691b256d72ec6ae
--- /dev/null
+++ b/es2panda/test/parser/js/test-array-expression-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+[a['b']c]
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-array-expression-2-expected.txt b/es2panda/test/parser/js/test-array-expression-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e6a1e214d125b2b1cbc5224ad35012ee7da3017b
--- /dev/null
+++ b/es2panda/test/parser/js/test-array-expression-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected ',' or ']' [test-array-expression-2.js:17:3]
diff --git a/es2panda/test/parser/js/test-array-expression-2.js b/es2panda/test/parser/js/test-array-expression-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f0300ffb35698893eed5e2a48f1bc4129e2e6e9
--- /dev/null
+++ b/es2panda/test/parser/js/test-array-expression-2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+[a;
diff --git a/es2panda/test/parser/js/test-array-expression-expected.txt b/es2panda/test/parser/js/test-array-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21231fa757f25e6fab2dbfc4018f313e8749182a
--- /dev/null
+++ b/es2panda/test/parser/js/test-array-expression-expected.txt
@@ -0,0 +1,492 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrayExpression",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 9
+              },
+              "end": {
+                "line": 17,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 3
+                },
+                "end": {
+                  "line": 20,
+                  "column": 4
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 3
+                },
+                "end": {
+                  "line": 22,
+                  "column": 4
+                }
+              }
+            },
+            {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 6
+                  }
+                }
+              },
+              "property": {
+                "type": "StringLiteral",
+                "value": "d",
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 10
+                  }
+                }
+              },
+              "computed": true,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 5
+                },
+                "end": {
+                  "line": 22,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 6
+                    }
+                  }
+                },
+                {
+                  "type": "CallExpression",
+                  "callee": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "arguments": [],
+                  "optional": false,
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 10
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 3
+                },
+                "end": {
+                  "line": 23,
+                  "column": 11
+                }
+              }
+            },
+            {
+              "type": "OmittedExpression",
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 3
+                },
+                "end": {
+                  "line": 25,
+                  "column": 4
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 3
+                },
+                "end": {
+                  "line": 26,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 2
+            }
+          }
+        },
+        "property": {
+          "type": "ArrayExpression",
+          "elements": [
+            {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "ArrayExpression",
+                  "elements": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 6
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 3
+                },
+                "end": {
+                  "line": 29,
+                  "column": 7
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 2
+            },
+            "end": {
+              "line": 29,
+              "column": 8
+            }
+          }
+        },
+        "computed": true,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "f",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 1
+            },
+            "end": {
+              "line": 31,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "CallExpression",
+                "callee": {
+                  "type": "ArrayExpression",
+                  "elements": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 8
+                    }
+                  }
+                },
+                "arguments": [],
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 5
+              },
+              "end": {
+                "line": 31,
+                "column": 11
+              }
+            }
+          },
+          "arguments": [],
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 5
+            },
+            "end": {
+              "line": 31,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 31,
+            "column": 1
+          },
+          "end": {
+            "line": 31,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrayExpression",
+        "elements": [
+          {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 2
+              },
+              "end": {
+                "line": 33,
+                "column": 3
+              }
+            }
+          },
+          {
+            "type": "SpreadElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "spread",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 8
+                },
+                "end": {
+                  "line": 33,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 14
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 1
+          },
+          "end": {
+            "line": 33,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 15
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 33,
+      "column": 15
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-array-expression.js b/es2panda/test/parser/js/test-array-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..2150a6ec721a03104a0ad27511d4b88ebe21076f
--- /dev/null
+++ b/es2panda/test/parser/js/test-array-expression.js
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let a = [];
+
+[
+  a
+  ,
+  b,c['d'],
+  ['',b()]
+  ,
+  ,
+  d
+]
+
+[[[[]]]]
+
+f = [[]()]();
+
+[0, ...spread]
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-arrow-function-expected.txt b/es2panda/test/parser/js/test-arrow-function-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..84142d02f6e4444a8fa2c256d243c21bee77406c
--- /dev/null
+++ b/es2panda/test/parser/js/test-arrow-function-expected.txt
@@ -0,0 +1,1707 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": false,
+          "expression": true,
+          "params": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 2
+                },
+                "end": {
+                  "line": 17,
+                  "column": 3
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 5
+                },
+                "end": {
+                  "line": 17,
+                  "column": 6
+                }
+              }
+            }
+          ],
+          "body": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 11
+              },
+              "end": {
+                "line": 17,
+                "column": 12
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 4
+              },
+              "end": {
+                "line": 19,
+                "column": 5
+              }
+            }
+          },
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 8
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 7
+                },
+                "end": {
+                  "line": 19,
+                  "column": 13
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 7
+              },
+              "end": {
+                "line": 19,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 1
+              },
+              "end": {
+                "line": 21,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 4
+              },
+              "end": {
+                "line": 21,
+                "column": 5
+              }
+            }
+          },
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 8
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "AssignmentExpression",
+                "operator": "+=",
+                "left": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 13
+                    }
+                  }
+                },
+                "right": {
+                  "type": "AssignmentExpression",
+                  "operator": "=",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 21,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "UpdateExpression",
+                    "operator": "++",
+                    "prefix": false,
+                    "argument": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 21,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 24
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 7
+                },
+                "end": {
+                  "line": 21,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 7
+              },
+              "end": {
+                "line": 21,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 1
+              },
+              "end": {
+                "line": 23,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 4
+              },
+              "end": {
+                "line": 23,
+                "column": 5
+              }
+            }
+          },
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 8
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "ReturnStatement",
+                    "argument": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 22
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 24
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 7
+                },
+                "end": {
+                  "line": 23,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 7
+              },
+              "end": {
+                "line": 23,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 2
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 3
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 6
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 9
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 1
+                },
+                "end": {
+                  "line": 25,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 1
+              },
+              "end": {
+                "line": 25,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 17
+              },
+              "end": {
+                "line": 25,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 20
+              },
+              "end": {
+                "line": 25,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 2
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 3
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 6
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 9
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 1
+                },
+                "end": {
+                  "line": 27,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 1
+              },
+              "end": {
+                "line": 27,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 17
+              },
+              "end": {
+                "line": 27,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 20
+              },
+              "end": {
+                "line": 27,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 1
+              },
+              "end": {
+                "line": 29,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 4
+              },
+              "end": {
+                "line": 29,
+                "column": 5
+              }
+            }
+          },
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 8
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 7
+                },
+                "end": {
+                  "line": 29,
+                  "column": 13
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 7
+              },
+              "end": {
+                "line": 29,
+                "column": 13
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 15
+              },
+              "end": {
+                "line": 29,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 18
+              },
+              "end": {
+                "line": 29,
+                "column": 19
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 5
+              },
+              "end": {
+                "line": 31,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 10
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 9
+                },
+                "end": {
+                  "line": 31,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 9
+              },
+              "end": {
+                "line": 31,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 5
+            },
+            "end": {
+              "line": 31,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "f",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 1
+            },
+            "end": {
+              "line": 33,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "ArrowFunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": true,
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 6
+                  }
+                }
+              }
+            ],
+            "body": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 10
+                },
+                "end": {
+                  "line": 33,
+                  "column": 11
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 5
+            },
+            "end": {
+              "line": 33,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 1
+          },
+          "end": {
+            "line": 33,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "g",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 10
+            },
+            "end": {
+              "line": 35,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "func",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 12
+              },
+              "end": {
+                "line": 35,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "CallExpression",
+                "callee": {
+                  "type": "Identifier",
+                  "name": "func",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 31
+                    }
+                  }
+                },
+                "arguments": [
+                  {
+                    "type": "NumberLiteral",
+                    "value": 123,
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 35
+                      }
+                    }
+                  }
+                ],
+                "optional": false,
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 20
+                },
+                "end": {
+                  "line": 35,
+                  "column": 36
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 18
+            },
+            "end": {
+              "line": 35,
+              "column": 38
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 35,
+            "column": 1
+          },
+          "end": {
+            "line": 35,
+            "column": 38
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "g",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 1
+            },
+            "end": {
+              "line": 37,
+              "column": 2
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "val",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 6
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "UpdateExpression",
+                "operator": "++",
+                "prefix": true,
+                "argument": {
+                  "type": "Identifier",
+                  "name": "val",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 15
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 3
+                },
+                "end": {
+                  "line": 37,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 3
+              },
+              "end": {
+                "line": 37,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 1
+          },
+          "end": {
+            "line": 37,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "ArrowFunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": true,
+            "params": [],
+            "body": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 8
+                },
+                "end": {
+                  "line": 39,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 2
+              },
+              "end": {
+                "line": 39,
+                "column": 9
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 39,
+              "column": 1
+            },
+            "end": {
+              "line": 39,
+              "column": 10
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 39,
+            "column": 1
+          },
+          "end": {
+            "line": 39,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 39,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "arrowWithParen",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 5
+              },
+              "end": {
+                "line": 41,
+                "column": 19
+              }
+            }
+          },
+          "init": {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "val",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "ObjectExpression",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": false,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "key",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 41,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 41,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "val",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 41,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 41,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 40
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 22
+                },
+                "end": {
+                  "line": 41,
+                  "column": 43
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 22
+              },
+              "end": {
+                "line": 41,
+                "column": 43
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 5
+            },
+            "end": {
+              "line": 41,
+              "column": 43
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 44
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 42,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-arrow-function.js b/es2panda/test/parser/js/test-arrow-function.js
new file mode 100644
index 0000000000000000000000000000000000000000..a4cf03851e4970246c73bb9b465a7c4d4f85705c
--- /dev/null
+++ b/es2panda/test/parser/js/test-arrow-function.js
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(a, b) => a
+
+a, b, c => c;
+
+a, b, c => a += b = c++;
+
+a, b, c => { return c }
+
+(a, b, c) => a, b, c;
+
+(a, b, c) => a, b, c
+
+a, b, c => c, b, a
+
+var f = a => a
+
+f = a => a
+
+function g(func) { return func(123) }
+
+g(val => ++val);
+
+(() => 1)()
+
+var arrowWithParen = val => ({ key: val });
diff --git a/es2panda/test/parser/js/test-assignment-expression-expected.txt b/es2panda/test/parser/js/test-assignment-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6c852caef78824bc15a6589bace0863695285f70
--- /dev/null
+++ b/es2panda/test/parser/js/test-assignment-expression-expected.txt
@@ -0,0 +1,828 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "right": {
+            "type": "NullLiteral",
+            "value": null,
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 9
+              },
+              "end": {
+                "line": 17,
+                "column": 13
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "*=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2.23,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 6
+            },
+            "end": {
+              "line": 18,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "/=",
+        "left": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 33,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 6
+            },
+            "end": {
+              "line": 19,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "%=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 6
+            },
+            "end": {
+              "line": 20,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BooleanLiteral",
+          "value": false,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "+=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "dsfdsfdsf",
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 7
+            },
+            "end": {
+              "line": 22,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "-=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "StringLiteral",
+          "value": "dfsd",
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 5
+            },
+            "end": {
+              "line": 23,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "<<=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 7
+            },
+            "end": {
+              "line": 24,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": ">>=",
+        "left": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 7
+            },
+            "end": {
+              "line": 25,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "<<=",
+        "left": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 1
+            },
+            "end": {
+              "line": 26,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 4,
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 7
+            },
+            "end": {
+              "line": 26,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "&=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 6
+            },
+            "end": {
+              "line": 27,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "^=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 1
+            },
+            "end": {
+              "line": 28,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 6
+            },
+            "end": {
+              "line": 28,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 1
+          },
+          "end": {
+            "line": 28,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "|=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 1
+            },
+            "end": {
+              "line": 29,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 21,
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 6
+            },
+            "end": {
+              "line": 29,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "**=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 1
+            },
+            "end": {
+              "line": 30,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 7
+            },
+            "end": {
+              "line": 30,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 1
+          },
+          "end": {
+            "line": 30,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 30,
+      "column": 9
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-assignment-expression.js b/es2panda/test/parser/js/test-assignment-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..d0b8f906db0582b5037c40cba73c3a876d460f2a
--- /dev/null
+++ b/es2panda/test/parser/js/test-assignment-expression.js
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = b = null;
+b *= 2.23;
+c /= 0x21;
+a %= 2;
+b = false;
+a +=  "dsfdsfdsf"
+a-= "dfsd"
+a <<= 2
+b >>= 3
+c <<= 4
+a &= 0;
+a ^= 2
+a |= 21
+a **= 12
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-async-arrow-function-1-expected.txt b/es2panda/test/parser/js/test-async-arrow-function-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ffb068cdfa519f6c7810c09fb80399b39cb62c16
--- /dev/null
+++ b/es2panda/test/parser/js/test-async-arrow-function-1-expected.txt
@@ -0,0 +1,358 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": true,
+          "expression": false,
+          "params": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 8
+                },
+                "end": {
+                  "line": 17,
+                  "column": 9
+                }
+              }
+            }
+          ],
+          "body": {
+            "type": "BlockStatement",
+            "statements": [
+              {
+                "type": "ReturnStatement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 24
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 25
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 14
+              },
+              "end": {
+                "line": 17,
+                "column": 27
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": true,
+          "expression": true,
+          "params": [
+            {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 7
+                },
+                "end": {
+                  "line": 18,
+                  "column": 8
+                }
+              }
+            }
+          ],
+          "body": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 12
+              },
+              "end": {
+                "line": 18,
+                "column": 13
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 7
+            },
+            "end": {
+              "line": 18,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "async",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "ArrowFunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": true,
+              "expression": true,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 13
+                },
+                "end": {
+                  "line": 19,
+                  "column": 19
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 7
+              },
+              "end": {
+                "line": 19,
+                "column": 19
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "async",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "Identifier",
+            "name": "async",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 7
+              },
+              "end": {
+                "line": 20,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 21,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-async-arrow-function-1.js b/es2panda/test/parser/js/test-async-arrow-function-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..fbd33e996d3d3afda3038fc4c08af62ec878d4a7
--- /dev/null
+++ b/es2panda/test/parser/js/test-async-arrow-function-1.js
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+async (a) => { return a; }
+async a => a
+async(async b => b)
+async(async);
diff --git a/es2panda/test/parser/js/test-async-function-1-expected.txt b/es2panda/test/parser/js/test-async-function-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4c57723213fc381c4c52690be36dbe17f0a7fa53
--- /dev/null
+++ b/es2panda/test/parser/js/test-async-function-1-expected.txt
@@ -0,0 +1,118 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "async",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 10
+              }
+            }
+          },
+          "init": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": {
+                "type": "Identifier",
+                "name": "async",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 33
+                  }
+                }
+              },
+              "generator": false,
+              "async": true,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 39
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 19
+                },
+                "end": {
+                  "line": 17,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 13
+              },
+              "end": {
+                "line": 17,
+                "column": 39
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 39
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 39
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 18,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-async-function-1.js b/es2panda/test/parser/js/test-async-function-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0887cfe232436c17e47b1e07123dfc66d17449d
--- /dev/null
+++ b/es2panda/test/parser/js/test-async-function-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var async = async function async() { }
diff --git a/es2panda/test/parser/js/test-async-function-2-expected.txt b/es2panda/test/parser/js/test-async-function-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bf02ac1b50ad9c9b7348563c35f7fd04260523e0
--- /dev/null
+++ b/es2panda/test/parser/js/test-async-function-2-expected.txt
@@ -0,0 +1,74 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "async",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 16
+            },
+            "end": {
+              "line": 17,
+              "column": 21
+            }
+          }
+        },
+        "generator": false,
+        "async": true,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 24
+            },
+            "end": {
+              "line": 17,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 7
+          },
+          "end": {
+            "line": 17,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 27
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 18,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-async-function-2.js b/es2panda/test/parser/js/test-async-function-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..b54a9ff133d4b729c969a6388e5abaa8f37e6f57
--- /dev/null
+++ b/es2panda/test/parser/js/test-async-function-2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+async function async() { }
diff --git a/es2panda/test/parser/js/test-binary-expression-expected.txt b/es2panda/test/parser/js/test-binary-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0e7b6b05aded0c244f0e031fac9f09397767ce2b
--- /dev/null
+++ b/es2panda/test/parser/js/test-binary-expression-expected.txt
@@ -0,0 +1,1758 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "|",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "^",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 5
+            },
+            "end": {
+              "line": 18,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "&",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 5
+            },
+            "end": {
+              "line": 19,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "==",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 6
+            },
+            "end": {
+              "line": 20,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "!=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 6
+            },
+            "end": {
+              "line": 21,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "===",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 7
+            },
+            "end": {
+              "line": 22,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "!==",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 7
+            },
+            "end": {
+              "line": 23,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "<",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 5
+            },
+            "end": {
+              "line": 24,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "<=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 6
+            },
+            "end": {
+              "line": 25,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": ">",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 1
+            },
+            "end": {
+              "line": 26,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 5
+            },
+            "end": {
+              "line": 26,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": ">=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 6
+            },
+            "end": {
+              "line": 27,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "<<",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 1
+            },
+            "end": {
+              "line": 28,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 6
+            },
+            "end": {
+              "line": 28,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 1
+          },
+          "end": {
+            "line": 28,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": ">>",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 1
+            },
+            "end": {
+              "line": 29,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 6
+            },
+            "end": {
+              "line": 29,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": ">>>",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 1
+            },
+            "end": {
+              "line": 30,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 7
+            },
+            "end": {
+              "line": 30,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 1
+          },
+          "end": {
+            "line": 30,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 1
+            },
+            "end": {
+              "line": 31,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 5
+            },
+            "end": {
+              "line": 31,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 31,
+            "column": 1
+          },
+          "end": {
+            "line": 31,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 1
+            },
+            "end": {
+              "line": 32,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 5
+            },
+            "end": {
+              "line": 32,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 1
+          },
+          "end": {
+            "line": 32,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "*",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 1
+            },
+            "end": {
+              "line": 33,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 5
+            },
+            "end": {
+              "line": 33,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 1
+          },
+          "end": {
+            "line": 33,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 1
+            },
+            "end": {
+              "line": 34,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 5
+            },
+            "end": {
+              "line": 34,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 1
+          },
+          "end": {
+            "line": 34,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 1
+            },
+            "end": {
+              "line": 35,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 5
+            },
+            "end": {
+              "line": 35,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 35,
+            "column": 1
+          },
+          "end": {
+            "line": 35,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "**",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 1
+            },
+            "end": {
+              "line": 36,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 6
+            },
+            "end": {
+              "line": 36,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 1
+          },
+          "end": {
+            "line": 36,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "instanceof",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 1
+            },
+            "end": {
+              "line": 37,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 14
+            },
+            "end": {
+              "line": 37,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 1
+          },
+          "end": {
+            "line": 37,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 1
+            },
+            "end": {
+              "line": 38,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 6
+            },
+            "end": {
+              "line": 38,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 1
+          },
+          "end": {
+            "line": 38,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "in",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": "instanceof",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 1
+              },
+              "end": {
+                "line": 40,
+                "column": 2
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 14
+              },
+              "end": {
+                "line": 40,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 1
+            },
+            "end": {
+              "line": 40,
+              "column": 15
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 19
+            },
+            "end": {
+              "line": 40,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 40,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 1
+            },
+            "end": {
+              "line": 41,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "^",
+          "left": {
+            "type": "BinaryExpression",
+            "operator": "-",
+            "left": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 6
+                },
+                "end": {
+                  "line": 41,
+                  "column": 7
+                }
+              }
+            },
+            "right": {
+              "type": "BinaryExpression",
+              "operator": "*",
+              "left": {
+                "type": "Identifier",
+                "name": "e",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 11
+                  }
+                }
+              },
+              "right": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 10
+                },
+                "end": {
+                  "line": 41,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 6
+              },
+              "end": {
+                "line": 41,
+                "column": 15
+              }
+            }
+          },
+          "right": {
+            "type": "BinaryExpression",
+            "operator": "%",
+            "left": {
+              "type": "Identifier",
+              "name": "g",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 18
+                },
+                "end": {
+                  "line": 41,
+                  "column": 19
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 22
+                },
+                "end": {
+                  "line": 41,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 18
+              },
+              "end": {
+                "line": 41,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 6
+            },
+            "end": {
+              "line": 41,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 1
+          },
+          "end": {
+            "line": 41,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": ">>>",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": ">>",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 1
+              },
+              "end": {
+                "line": 42,
+                "column": 2
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 6
+              },
+              "end": {
+                "line": 42,
+                "column": 7
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 1
+            },
+            "end": {
+              "line": 42,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 42,
+              "column": 12
+            },
+            "end": {
+              "line": 42,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 1
+          },
+          "end": {
+            "line": 42,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 42,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": "-",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 43,
+                "column": 1
+              },
+              "end": {
+                "line": 43,
+                "column": 2
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 43,
+                "column": 5
+              },
+              "end": {
+                "line": 43,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 43,
+              "column": 1
+            },
+            "end": {
+              "line": 43,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": {
+            "type": "BinaryExpression",
+            "operator": "/",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 10
+                },
+                "end": {
+                  "line": 43,
+                  "column": 11
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "e",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 14
+                },
+                "end": {
+                  "line": 43,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 43,
+                "column": 10
+              },
+              "end": {
+                "line": 43,
+                "column": 15
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "f",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 43,
+                "column": 19
+              },
+              "end": {
+                "line": 43,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 43,
+              "column": 10
+            },
+            "end": {
+              "line": 43,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 43,
+            "column": 1
+          },
+          "end": {
+            "line": 43,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 43,
+          "column": 1
+        },
+        "end": {
+          "line": 43,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 44,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-binary-expression.js b/es2panda/test/parser/js/test-binary-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..781ea621b6bc14bfcc5c7f67551c607db609f8f9
--- /dev/null
+++ b/es2panda/test/parser/js/test-binary-expression.js
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a | b
+a ^ b
+a & b
+a == b
+a != b
+a === b
+a !== b
+a < b
+a <= b
+a > b
+a >= b
+a << b
+a >> b
+a >>> b
+a + b
+a - b
+a * b
+a / b
+a % b
+a ** b
+a instanceof b
+a in b
+
+a instanceof b in c
+a && b - e * b ^ g % d
+a >> b >>> c
+a - b || c / e && f
diff --git a/es2panda/test/parser/js/test-call-expression-expected.txt b/es2panda/test/parser/js/test-call-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..91d9d8e818c9b7b5fe938a52f4819c85ab9498e5
--- /dev/null
+++ b/es2panda/test/parser/js/test-call-expression-expected.txt
@@ -0,0 +1,583 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "CallExpression",
+              "callee": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 7
+                  }
+                }
+              },
+              "arguments": [
+                {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 10
+                    }
+                  }
+                }
+              ],
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 6
+                },
+                "end": {
+                  "line": 17,
+                  "column": 11
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "BinaryExpression",
+                "operator": "+",
+                "left": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 18,
+                      "column": 2
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 3
+                    }
+                  }
+                },
+                "right": {
+                  "type": "NumberLiteral",
+                  "value": 2,
+                  "loc": {
+                    "start": {
+                      "line": 18,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 5
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 5
+                  }
+                }
+              }
+            ],
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 6
+              },
+              "end": {
+                "line": 18,
+                "column": 6
+              }
+            }
+          },
+          "arguments": [
+            {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 7
+                },
+                "end": {
+                  "line": 18,
+                  "column": 8
+                }
+              }
+            }
+          ],
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 6
+            },
+            "end": {
+              "line": 18,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 2
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 3
+              },
+              "end": {
+                "line": 19,
+                "column": 4
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 5
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 5
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 2
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 2
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "SpreadElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 6
+                },
+                "end": {
+                  "line": 21,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 3
+              },
+              "end": {
+                "line": 21,
+                "column": 9
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 11
+              },
+              "end": {
+                "line": 21,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "StringLiteral",
+          "value": "123",
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 7
+              },
+              "end": {
+                "line": 22,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "LogicalExpression",
+          "operator": "||",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 2
+              },
+              "end": {
+                "line": 23,
+                "column": 3
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 6
+              },
+              "end": {
+                "line": 23,
+                "column": 7
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 8
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 9
+              },
+              "end": {
+                "line": 23,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 2
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 3
+              },
+              "end": {
+                "line": 24,
+                "column": 4
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 24,
+      "column": 6
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-call-expression.js b/es2panda/test/parser/js/test-call-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cdaa3b034b63b2e1f4977243bd1c6599a93b660
--- /dev/null
+++ b/es2panda/test/parser/js/test-call-expression.js
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+1 || 2 (d)
+(1+2)(c)
+a(b)
+a()
+a(...(b), c)
+"123"(a);
+(a|| b)(c)
+a(1,)
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-class-async-method-expected.txt b/es2panda/test/parser/js/test-class-async-method-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eee1c974e13f2b3f510f3c90934f1ba71a32bfd2
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-async-method-expected.txt
@@ -0,0 +1,219 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 7
+            },
+            "end": {
+              "line": 17,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 2
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "async",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 16
+                },
+                "end": {
+                  "line": 18,
+                  "column": 21
+                }
+              }
+            },
+            "kind": "method",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": true,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 18,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 26
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 21
+                },
+                "end": {
+                  "line": 18,
+                  "column": 26
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 3
+              },
+              "end": {
+                "line": 18,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 9
+          },
+          "end": {
+            "line": 19,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 20,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-class-async-method.js b/es2panda/test/parser/js/test-class-async-method.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b16ddd077215d42238e3b8897765dc5591a4fa7
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-async-method.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class C {
+  static async async() {}
+}
diff --git a/es2panda/test/parser/js/test-class-definition-expected.txt b/es2panda/test/parser/js/test-class-definition-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4c5877e8153e2a657db9926e64c19762abc17257
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition-expected.txt
@@ -0,0 +1,1317 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 7
+            },
+            "end": {
+              "line": 17,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 3
+              },
+              "end": {
+                "line": 24,
+                "column": 14
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 22
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 4
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 14
+                },
+                "end": {
+                  "line": 26,
+                  "column": 4
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 14
+              },
+              "end": {
+                "line": 26,
+                "column": 4
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 3
+            },
+            "end": {
+              "line": 26,
+              "column": 4
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "myStaticFunc",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 10
+                },
+                "end": {
+                  "line": 18,
+                  "column": 22
+                }
+              }
+            },
+            "kind": "method",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 24
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 27
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 30
+                      }
+                    }
+                  }
+                ],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 18,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 34
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 34
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 22
+                },
+                "end": {
+                  "line": 18,
+                  "column": 34
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 3
+              },
+              "end": {
+                "line": 18,
+                "column": 34
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "myFunc",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 3
+                },
+                "end": {
+                  "line": 20,
+                  "column": 9
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 4
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 4
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 9
+                },
+                "end": {
+                  "line": 22,
+                  "column": 4
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 3
+              },
+              "end": {
+                "line": 22,
+                "column": 4
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 9
+          },
+          "end": {
+            "line": 27,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "B",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 7
+            },
+            "end": {
+              "line": 29,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 3
+              },
+              "end": {
+                "line": 34,
+                "column": 14
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 14
+                },
+                "end": {
+                  "line": 34,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 14
+              },
+              "end": {
+                "line": 34,
+                "column": 18
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 3
+            },
+            "end": {
+              "line": 34,
+              "column": 18
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "static",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 16
+                },
+                "end": {
+                  "line": 30,
+                  "column": 22
+                }
+              }
+            },
+            "kind": "method",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": true,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 26
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 22
+                },
+                "end": {
+                  "line": 30,
+                  "column": 26
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 3
+              },
+              "end": {
+                "line": 30,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 15
+                },
+                "end": {
+                  "line": 31,
+                  "column": 16
+                }
+              }
+            },
+            "kind": "get",
+            "static": true,
+            "optional": false,
+            "computed": true,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 17
+                },
+                "end": {
+                  "line": 31,
+                  "column": 21
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 3
+              },
+              "end": {
+                "line": 31,
+                "column": 21
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "get",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 16
+                },
+                "end": {
+                  "line": 32,
+                  "column": 19
+                }
+              }
+            },
+            "kind": "method",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": true,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 23
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 19
+                },
+                "end": {
+                  "line": 32,
+                  "column": 23
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 3
+              },
+              "end": {
+                "line": 32,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 10
+                },
+                "end": {
+                  "line": 33,
+                  "column": 21
+                }
+              }
+            },
+            "kind": "method",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 25
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 21
+                },
+                "end": {
+                  "line": 33,
+                  "column": 25
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 3
+              },
+              "end": {
+                "line": 33,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 8
+                },
+                "end": {
+                  "line": 35,
+                  "column": 9
+                }
+              }
+            },
+            "kind": "set",
+            "static": false,
+            "optional": false,
+            "computed": true,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 12
+                      }
+                    }
+                  }
+                ],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 15
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 10
+                },
+                "end": {
+                  "line": 35,
+                  "column": 15
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 3
+              },
+              "end": {
+                "line": 35,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "StringLiteral",
+              "value": "foo",
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 7
+                },
+                "end": {
+                  "line": 36,
+                  "column": 12
+                }
+              }
+            },
+            "kind": "get",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 16
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 12
+                },
+                "end": {
+                  "line": 36,
+                  "column": 16
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 3
+              },
+              "end": {
+                "line": 36,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 4
+                },
+                "end": {
+                  "line": 37,
+                  "column": 5
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": true,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 9
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 5
+                },
+                "end": {
+                  "line": 37,
+                  "column": 9
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 3
+              },
+              "end": {
+                "line": 37,
+                "column": 9
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 10
+                },
+                "end": {
+                  "line": 38,
+                  "column": 11
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": true,
+                "async": true,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 15
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 38,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 38,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 11
+                },
+                "end": {
+                  "line": 38,
+                  "column": 15
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 3
+              },
+              "end": {
+                "line": 38,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "StringLiteral",
+              "value": "bar",
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 5
+                },
+                "end": {
+                  "line": 39,
+                  "column": 10
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": true,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": true,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 39,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 39,
+                      "column": 15
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 11
+                },
+                "end": {
+                  "line": 39,
+                  "column": 15
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 3
+              },
+              "end": {
+                "line": 39,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "StringLiteral",
+              "value": "baz",
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 12
+                },
+                "end": {
+                  "line": 40,
+                  "column": 17
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": true,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": true,
+                "async": true,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 40,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 40,
+                      "column": 22
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 18
+                },
+                "end": {
+                  "line": 40,
+                  "column": 22
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 3
+              },
+              "end": {
+                "line": 40,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 9
+          },
+          "end": {
+            "line": 41,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 41,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-class-definition.js b/es2panda/test/parser/js/test-class-definition.js
new file mode 100644
index 0000000000000000000000000000000000000000..acae759635e916a0137188728bdc6db2a204a966
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition.js
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+  static myStaticFunc(a, b, c) {}
+
+  myFunc() {
+
+  }
+
+  constructor(a, b, c)
+  {
+  }
+}
+
+class B {
+  static async static(){}
+  static get [a](){}
+  static async get(){}
+  static constructor(){}
+  constructor(){}
+  set [5](a){}
+  get "foo"(){}
+  *a(){}
+  async *a(){}
+  *["bar"](){}
+  async * ["baz"](){}
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-class-definition1-expected.txt b/es2panda/test/parser/js/test-class-definition1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a8a2cf40f74a8422a144be2b257f419e1f6ac2e
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected super keyword [test-class-definition1.js:20:10]
diff --git a/es2panda/test/parser/js/test-class-definition1.js b/es2panda/test/parser/js/test-class-definition1.js
new file mode 100644
index 0000000000000000000000000000000000000000..1205bb873039a4bab70d158f590b131c555879df
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition1.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+  constructor()
+  {
+    super();
+  }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-class-definition2-expected.txt b/es2panda/test/parser/js/test-class-definition2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4d4b8b498269e6c89cf05a790df8c882864a7a9e
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Multiple constructor implementations are not allowed. [test-class-definition2.js:21:5]
diff --git a/es2panda/test/parser/js/test-class-definition2.js b/es2panda/test/parser/js/test-class-definition2.js
new file mode 100644
index 0000000000000000000000000000000000000000..4476239a0c0bca92cf4c65da8ad60ea2e2e21d92
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition2.js
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+  constructor() {
+    return 42;
+  }
+    constructor() {
+    return 42;
+  }
+}
+  
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-class-definition3-expected.txt b/es2panda/test/parser/js/test-class-definition3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0fe156f152d376eeb78a7f8ae412755f6c1f37b6
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected super keyword [test-class-definition3.js:20:10]
diff --git a/es2panda/test/parser/js/test-class-definition3.js b/es2panda/test/parser/js/test-class-definition3.js
new file mode 100644
index 0000000000000000000000000000000000000000..4a0ee620e53975ceca331cdf0d5a865e0a1724d9
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition3.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {};
+class B extends A {
+  static constructor() {
+    super();
+  }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-class-definition4-expected.txt b/es2panda/test/parser/js/test-class-definition4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a1df800525b27c3c49d4cf9dc0cf7b9fd5810b7
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Classes may not have static property named prototype [test-class-definition4.js:18:10]
diff --git a/es2panda/test/parser/js/test-class-definition4.js b/es2panda/test/parser/js/test-class-definition4.js
new file mode 100644
index 0000000000000000000000000000000000000000..65e4ff9068571fb294b704f32aa1867587ffbc60
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition4.js
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class B {
+  static prototype() {
+  }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-class-definition5-expected.txt b/es2panda/test/parser/js/test-class-definition5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1e0905fff71377f28c81be2765be421822c4247e
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Constructor can not be special method [test-class-definition5.js:18:7]
diff --git a/es2panda/test/parser/js/test-class-definition5.js b/es2panda/test/parser/js/test-class-definition5.js
new file mode 100644
index 0000000000000000000000000000000000000000..fa4ac29d4ce71a9a2cdf21efc24516c7b4e1c6e0
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-definition5.js
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+  get constructor() {
+  }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-class-expression-expected.txt b/es2panda/test/parser/js/test-class-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cddfbc38f8bd55f94762c52877576a3da4941cd6
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-expression-expected.txt
@@ -0,0 +1,756 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "cls1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 5
+              },
+              "end": {
+                "line": 19,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ClassExpression",
+            "definition": {
+              "id": {
+                "type": "Identifier",
+                "name": "C",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 19
+                  }
+                }
+              },
+              "superClass": null,
+              "implements": [],
+              "constructor": {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "kind": "constructor",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 1
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 1
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 2
+                  }
+                }
+              },
+              "body": [
+                {
+                  "type": "MethodDefinition",
+                  "key": {
+                    "type": "Identifier",
+                    "name": "method",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 3
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "kind": "method",
+                  "static": false,
+                  "optional": false,
+                  "computed": false,
+                  "value": {
+                    "type": "FunctionExpression",
+                    "function": {
+                      "type": "ScriptFunction",
+                      "id": null,
+                      "generator": false,
+                      "async": false,
+                      "expression": false,
+                      "params": [],
+                      "body": {
+                        "type": "BlockStatement",
+                        "statements": [
+                          {
+                            "type": "ReturnStatement",
+                            "argument": {
+                              "type": "Identifier",
+                              "name": "C",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 21,
+                                  "column": 12
+                                },
+                                "end": {
+                                  "line": 21,
+                                  "column": 13
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 5
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 14
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 20,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 4
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 4
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 4
+                      }
+                    }
+                  },
+                  "overloads": [],
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 4
+                    }
+                  }
+                },
+                {
+                  "type": "MethodDefinition",
+                  "key": {
+                    "type": "Identifier",
+                    "name": "staticMethod",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "kind": "method",
+                  "static": true,
+                  "optional": false,
+                  "computed": false,
+                  "value": {
+                    "type": "FunctionExpression",
+                    "function": {
+                      "type": "ScriptFunction",
+                      "id": null,
+                      "generator": false,
+                      "async": false,
+                      "expression": false,
+                      "params": [],
+                      "body": {
+                        "type": "BlockStatement",
+                        "statements": [
+                          {
+                            "type": "ReturnStatement",
+                            "argument": {
+                              "type": "Identifier",
+                              "name": "C",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 25,
+                                  "column": 12
+                                },
+                                "end": {
+                                  "line": 25,
+                                  "column": 13
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 25,
+                                "column": 5
+                              },
+                              "end": {
+                                "line": 25,
+                                "column": 14
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 4
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 26,
+                          "column": 4
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 4
+                      }
+                    }
+                  },
+                  "overloads": [],
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 4
+                    }
+                  }
+                }
+              ],
+              "indexSignatures": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 20
+                },
+                "end": {
+                  "line": 27,
+                  "column": 2
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 12
+              },
+              "end": {
+                "line": 27,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 5
+            },
+            "end": {
+              "line": 27,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 3
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "cls2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 9
+              }
+            }
+          },
+          "init": {
+            "type": "ClassExpression",
+            "definition": {
+              "id": null,
+              "superClass": null,
+              "implements": [],
+              "constructor": {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "kind": "constructor",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 1
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 1
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 2
+                  }
+                }
+              },
+              "body": [
+                {
+                  "type": "MethodDefinition",
+                  "key": {
+                    "type": "Identifier",
+                    "name": "method",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 3
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "kind": "method",
+                  "static": false,
+                  "optional": false,
+                  "computed": false,
+                  "value": {
+                    "type": "FunctionExpression",
+                    "function": {
+                      "type": "ScriptFunction",
+                      "id": null,
+                      "generator": false,
+                      "async": false,
+                      "expression": false,
+                      "params": [],
+                      "body": {
+                        "type": "BlockStatement",
+                        "statements": [],
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 15
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "overloads": [],
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 15
+                    }
+                  }
+                },
+                {
+                  "type": "MethodDefinition",
+                  "key": {
+                    "type": "Identifier",
+                    "name": "staticMethod",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "kind": "method",
+                  "static": true,
+                  "optional": false,
+                  "computed": false,
+                  "value": {
+                    "type": "FunctionExpression",
+                    "function": {
+                      "type": "ScriptFunction",
+                      "id": null,
+                      "generator": false,
+                      "async": false,
+                      "expression": false,
+                      "params": [],
+                      "body": {
+                        "type": "BlockStatement",
+                        "statements": [],
+                        "loc": {
+                          "start": {
+                            "line": 31,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 31,
+                            "column": 28
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 28
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "overloads": [],
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 28
+                    }
+                  }
+                }
+              ],
+              "indexSignatures": [],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 18
+                },
+                "end": {
+                  "line": 32,
+                  "column": 2
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 12
+              },
+              "end": {
+                "line": 32,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 32,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 33,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-class-expression.js b/es2panda/test/parser/js/test-class-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..d12d33975e35cdd374b45bba0e70b4c58524af9f
--- /dev/null
+++ b/es2panda/test/parser/js/test-class-expression.js
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var C;
+
+var cls1 = class C {
+  method() {
+    return C;
+  }
+
+  static staticMethod() {
+    return C;
+  }
+};
+
+var cls2 = class {
+  method() { }
+  static staticMethod() { }
+}
diff --git a/es2panda/test/parser/js/test-comment-expected.txt b/es2panda/test/parser/js/test-comment-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..93e710f2e98fc79dc697ee032b74609d6d7a9802
--- /dev/null
+++ b/es2panda/test/parser/js/test-comment-expected.txt
@@ -0,0 +1,14 @@
+{
+  "type": "Program",
+  "statements": [],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 22,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-comment.js b/es2panda/test/parser/js/test-comment.js
new file mode 100644
index 0000000000000000000000000000000000000000..926c84ba3cdd9eb5ca00a058439ee41221e69cec
--- /dev/null
+++ b/es2panda/test/parser/js/test-comment.js
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*
+var a = 4;
+a += 5;
+{}
+*/
diff --git a/es2panda/test/parser/js/test-conditional-expression-expected.txt b/es2panda/test/parser/js/test-conditional-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..db735e2da8736053d84ebf41235b77d4e881623c
--- /dev/null
+++ b/es2panda/test/parser/js/test-conditional-expression-expected.txt
@@ -0,0 +1,471 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ConditionalExpression",
+        "test": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 2
+            }
+          }
+        },
+        "consequent": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        },
+        "alternate": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 9
+            },
+            "end": {
+              "line": 17,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ConditionalExpression",
+        "test": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 2
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 6
+              },
+              "end": {
+                "line": 19,
+                "column": 7
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 7
+            }
+          }
+        },
+        "consequent": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 5
+            },
+            "end": {
+              "line": 20,
+              "column": 6
+            }
+          }
+        },
+        "alternate": {
+          "type": "NumberLiteral",
+          "value": 42,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "res",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 5
+              },
+              "end": {
+                "line": 23,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "ConditionalExpression",
+            "test": {
+              "type": "BinaryExpression",
+              "operator": "==",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 13
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 12
+                },
+                "end": {
+                  "line": 23,
+                  "column": 18
+                }
+              }
+            },
+            "consequent": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 21
+                },
+                "end": {
+                  "line": 23,
+                  "column": 22
+                }
+              }
+            },
+            "alternate": {
+              "type": "NumberLiteral",
+              "value": 42,
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 25
+                },
+                "end": {
+                  "line": 23,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 11
+              },
+              "end": {
+                "line": 23,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 5
+            },
+            "end": {
+              "line": 23,
+              "column": 28
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ConditionalExpression",
+        "test": {
+          "type": "LogicalExpression",
+          "operator": "||",
+          "left": {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 1
+                },
+                "end": {
+                  "line": 25,
+                  "column": 2
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 6
+                },
+                "end": {
+                  "line": 25,
+                  "column": 7
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 1
+              },
+              "end": {
+                "line": 25,
+                "column": 7
+              }
+            }
+          },
+          "right": {
+            "type": "BinaryExpression",
+            "operator": "==",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 11
+                },
+                "end": {
+                  "line": 25,
+                  "column": 12
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 16
+                },
+                "end": {
+                  "line": 25,
+                  "column": 17
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 11
+              },
+              "end": {
+                "line": 25,
+                "column": 17
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 17
+            }
+          }
+        },
+        "consequent": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 20
+            },
+            "end": {
+              "line": 25,
+              "column": 21
+            }
+          }
+        },
+        "alternate": {
+          "type": "Identifier",
+          "name": "f",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 24
+            },
+            "end": {
+              "line": 25,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 25
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 26,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-conditional-expression.js b/es2panda/test/parser/js/test-conditional-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..c469d76acda727378bf3f8463450d8618480b64f
--- /dev/null
+++ b/es2panda/test/parser/js/test-conditional-expression.js
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a ? b : c
+
+a == 1
+  ? a
+  : 42
+
+var res = (a == 1 ? a : 42);
+
+a && b || c == d ? e : f
diff --git a/es2panda/test/parser/js/test-const-without-init-expected.txt b/es2panda/test/parser/js/test-const-without-init-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..451b52ffa477128aa39cca19e42c8f0fcb0c2255
--- /dev/null
+++ b/es2panda/test/parser/js/test-const-without-init-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Missing initializer in const declaration [test-const-without-init.js:17:8]
diff --git a/es2panda/test/parser/js/test-const-without-init.js b/es2panda/test/parser/js/test-const-without-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..b1ba15c3fe239ea74a6a2cec5910a3145abfea2f
--- /dev/null
+++ b/es2panda/test/parser/js/test-const-without-init.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+const c;
diff --git a/es2panda/test/parser/js/test-continue-in-switch-expected.txt b/es2panda/test/parser/js/test-continue-in-switch-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2e489788797b8b0fc04551c5f4bd6916b0708b62
--- /dev/null
+++ b/es2panda/test/parser/js/test-continue-in-switch-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Illegal continue statement [test-continue-in-switch.js:23:5]
diff --git a/es2panda/test/parser/js/test-continue-in-switch.js b/es2panda/test/parser/js/test-continue-in-switch.js
new file mode 100644
index 0000000000000000000000000000000000000000..d94995d2430b886756d9684c8b8bad8dd3859b1c
--- /dev/null
+++ b/es2panda/test/parser/js/test-continue-in-switch.js
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var a = 0;
+
+switch (a)
+{
+  case 1:
+    break;
+  case 2:
+    continue;
+  default:
+    break;
+}
diff --git a/es2panda/test/parser/js/test-debugger-statement-expected.txt b/es2panda/test/parser/js/test-debugger-statement-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d55d9f7e904b8eea0ccd3600dfe6f0373dc5bd5d
--- /dev/null
+++ b/es2panda/test/parser/js/test-debugger-statement-expected.txt
@@ -0,0 +1,97 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "DebuggerStatement",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "DebuggerStatement",
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "BlockStatement",
+      "statements": [
+        {
+          "type": "DebuggerStatement",
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 3
+            },
+            "end": {
+              "line": 22,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "BlockStatement",
+      "statements": [
+        {
+          "type": "DebuggerStatement",
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 3
+            },
+            "end": {
+              "line": 25,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 26,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-debugger-statement.js b/es2panda/test/parser/js/test-debugger-statement.js
new file mode 100644
index 0000000000000000000000000000000000000000..af618ee9853a3ebeeed3de265dbaa1553cb36a0d
--- /dev/null
+++ b/es2panda/test/parser/js/test-debugger-statement.js
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+debugger;
+
+debugger
+
+{
+  debugger
+}
+
+{ debugger }
diff --git a/es2panda/test/parser/js/test-delete-identifier-expected.txt b/es2panda/test/parser/js/test-delete-identifier-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6482b7c4e99398f188a422044f6c00266efd694a
--- /dev/null
+++ b/es2panda/test/parser/js/test-delete-identifier-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Deleting local variable in strict mode [test-delete-identifier.js:18:9]
diff --git a/es2panda/test/parser/js/test-delete-identifier.js b/es2panda/test/parser/js/test-delete-identifier.js
new file mode 100644
index 0000000000000000000000000000000000000000..ccf91ead0b68eb19cf56c75044e8d91bac1bee61
--- /dev/null
+++ b/es2panda/test/parser/js/test-delete-identifier.js
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a;
+delete a;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-do-while-1-expected.txt b/es2panda/test/parser/js/test-do-while-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c047fcef528a700ea7076c8ca13d2a35ace70ca6
--- /dev/null
+++ b/es2panda/test/parser/js/test-do-while-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-do-while-1.js:17:10]
diff --git a/es2panda/test/parser/js/test-do-while-1.js b/es2panda/test/parser/js/test-do-while-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..1a0cc0c12161a205b0b74f49e54cacdde89dad66
--- /dev/null
+++ b/es2panda/test/parser/js/test-do-while-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+do a = 2 while (a > b)
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-do-while-expected.txt b/es2panda/test/parser/js/test-do-while-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5c7ae338cc41191b6b8fb82dbfe4d92c1771911f
--- /dev/null
+++ b/es2panda/test/parser/js/test-do-while-expected.txt
@@ -0,0 +1,719 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "DoWhileStatement",
+      "body": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 4
+              },
+              "end": {
+                "line": 17,
+                "column": 5
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 8
+              },
+              "end": {
+                "line": 17,
+                "column": 9
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 4
+            },
+            "end": {
+              "line": 17,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 4
+          },
+          "end": {
+            "line": 17,
+            "column": 9
+          }
+        }
+      },
+      "test": {
+        "type": "BinaryExpression",
+        "operator": ">",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 8
+            },
+            "end": {
+              "line": 18,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 12
+            },
+            "end": {
+              "line": 18,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 8
+          },
+          "end": {
+            "line": 18,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "DoWhileStatement",
+      "body": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 4
+              },
+              "end": {
+                "line": 20,
+                "column": 5
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 8
+              },
+              "end": {
+                "line": 20,
+                "column": 9
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 4
+            },
+            "end": {
+              "line": 20,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 4
+          },
+          "end": {
+            "line": 20,
+            "column": 10
+          }
+        }
+      },
+      "test": {
+        "type": "BinaryExpression",
+        "operator": ">",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 18
+            },
+            "end": {
+              "line": 20,
+              "column": 19
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 22
+            },
+            "end": {
+              "line": 20,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 18
+          },
+          "end": {
+            "line": 20,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "DoWhileStatement",
+      "body": {
+        "type": "BlockStatement",
+        "statements": [
+          {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 7
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 6
+                },
+                "end": {
+                  "line": 22,
+                  "column": 11
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 6
+              },
+              "end": {
+                "line": 22,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 4
+          },
+          "end": {
+            "line": 22,
+            "column": 13
+          }
+        }
+      },
+      "test": {
+        "type": "BinaryExpression",
+        "operator": ">",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 21
+            },
+            "end": {
+              "line": 22,
+              "column": 22
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 25
+            },
+            "end": {
+              "line": 22,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 21
+          },
+          "end": {
+            "line": 22,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "DoWhileStatement",
+      "body": {
+        "type": "BlockStatement",
+        "statements": [
+          {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 7
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 6
+                },
+                "end": {
+                  "line": 24,
+                  "column": 11
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 6
+              },
+              "end": {
+                "line": 24,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 4
+          },
+          "end": {
+            "line": 24,
+            "column": 14
+          }
+        }
+      },
+      "test": {
+        "type": "BinaryExpression",
+        "operator": ">",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 22
+            },
+            "end": {
+              "line": 24,
+              "column": 23
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 26
+            },
+            "end": {
+              "line": 24,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 22
+          },
+          "end": {
+            "line": 24,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "DoWhileStatement",
+      "body": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 5
+              },
+              "end": {
+                "line": 27,
+                "column": 6
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 9
+              },
+              "end": {
+                "line": 27,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 5
+            },
+            "end": {
+              "line": 27,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 5
+          },
+          "end": {
+            "line": 27,
+            "column": 10
+          }
+        }
+      },
+      "test": {
+        "type": "BooleanLiteral",
+        "value": false,
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 8
+          },
+          "end": {
+            "line": 28,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "DoWhileStatement",
+      "body": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 4
+          },
+          "end": {
+            "line": 30,
+            "column": 7
+          }
+        }
+      },
+      "test": {
+        "type": "BooleanLiteral",
+        "value": false,
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 15
+          },
+          "end": {
+            "line": 30,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "DoWhileStatement",
+      "body": {
+        "type": "BlockStatement",
+        "statements": [
+          {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 6
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 5
+                },
+                "end": {
+                  "line": 33,
+                  "column": 10
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 4
+          },
+          "end": {
+            "line": 34,
+            "column": 2
+          }
+        }
+      },
+      "test": {
+        "type": "BooleanLiteral",
+        "value": false,
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 10
+          },
+          "end": {
+            "line": 34,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 45,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-do-while.js b/es2panda/test/parser/js/test-do-while.js
new file mode 100644
index 0000000000000000000000000000000000000000..af0e6445dc303651802dc0b0cab1ce4c4504a85e
--- /dev/null
+++ b/es2panda/test/parser/js/test-do-while.js
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+do a = 2
+while (a > b)
+
+do a = 2; while (a > b)
+
+do { a = 2 } while (a > b)
+
+do { a = 2; } while (a > b)
+
+do
+    a = 2
+while (false)
+
+do { } while (false);
+
+do {
+    a = 2;
+} while (false);
+
+/*
+TODO: fix these cases
+do do a = 2
+while (a > b) while (a > b)
+do a = 2; while (1) if(1) {}
+do a = 2; while (1) for(;;) {}
+do a = 2; while (1) function f() {}
+do a = 2; while (1) throw 'a'
+*/
diff --git a/es2panda/test/parser/js/test-escaped-keyword-expected.txt b/es2panda/test/parser/js/test-escaped-keyword-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1903c8c01a5189fd624dbc49ec5b60a340f39f8b
--- /dev/null
+++ b/es2panda/test/parser/js/test-escaped-keyword-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Escape sequences are not allowed in keywords [test-escaped-keyword.js:16:616]
diff --git a/es2panda/test/parser/js/test-escaped-keyword.js b/es2panda/test/parser/js/test-escaped-keyword.js
new file mode 100644
index 0000000000000000000000000000000000000000..831475126e5b88307870d724a8644ebc69450e42
--- /dev/null
+++ b/es2panda/test/parser/js/test-escaped-keyword.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+cl\u0061ss;
diff --git a/es2panda/test/parser/js/test-export-all-expected.txt b/es2panda/test/parser/js/test-export-all-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b649e5690b24b99ca4b582d1743a09bc6cca4642
--- /dev/null
+++ b/es2panda/test/parser/js/test-export-all-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'import' and 'export' may appear only with 'sourceType: module' [test-export-all.js:20:1]
diff --git a/es2panda/test/parser/js/test-export-all.js b/es2panda/test/parser/js/test-export-all.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba414e41cd1cf774f9b3bdc90a30086492e49ae1
--- /dev/null
+++ b/es2panda/test/parser/js/test-export-all.js
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*---
+flags: [module]
+---*/
+
+export * from 'foo'
+export * from 'bar';
diff --git a/es2panda/test/parser/js/test-export-named-decl-expected.txt b/es2panda/test/parser/js/test-export-named-decl-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2fae2a9c531c52ca67f19d872d2949fa5016984a
--- /dev/null
+++ b/es2panda/test/parser/js/test-export-named-decl-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'import' and 'export' may appear only with 'sourceType: module' [test-export-named-decl.js:20:1]
diff --git a/es2panda/test/parser/js/test-export-named-decl.js b/es2panda/test/parser/js/test-export-named-decl.js
new file mode 100644
index 0000000000000000000000000000000000000000..1048902428356a65e2974a0c834b92ae58d933f8
--- /dev/null
+++ b/es2panda/test/parser/js/test-export-named-decl.js
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*---
+flags: [module]
+---*/
+
+export { a as b, c} from "foo"
+export {}
+export var e = 1;
+export {} from "bar"
+export function f() {}
+export async function g() {}
+export function* h() {}
+export class i{};
+export let j = 2;
+export const k = true;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-expression-after-unary-expression-expected.txt b/es2panda/test/parser/js/test-expression-after-unary-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..250ae22d778de97c0413c662b8726b0efac3e518
--- /dev/null
+++ b/es2panda/test/parser/js/test-expression-after-unary-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-expression-after-unary-expression.js:17:4]
diff --git a/es2panda/test/parser/js/test-expression-after-unary-expression.js b/es2panda/test/parser/js/test-expression-after-unary-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..dacdf9f2b70359ec79e564416f6ea0a580e444fd
--- /dev/null
+++ b/es2panda/test/parser/js/test-expression-after-unary-expression.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+~a b
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-for-1-expected.txt b/es2panda/test/parser/js/test-for-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..848066b4d54bf4ab1f7b9ab385b2d53e9bfba58c
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-for-1.js:17:6]
diff --git a/es2panda/test/parser/js/test-for-1.js b/es2panda/test/parser/js/test-for-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..d55e403d8933b6fee6225bab062026303000b422
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+for () {}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-for-2-expected.txt b/es2panda/test/parser/js/test-for-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eeb705e8e3187265b64198609fdd5184b6e38a10
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-for-2.js:17:7]
diff --git a/es2panda/test/parser/js/test-for-2.js b/es2panda/test/parser/js/test-for-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..accd02a3e5c343c908dc20a931b4400acaa4d877
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+for (;) {}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-for-3-expected.txt b/es2panda/test/parser/js/test-for-3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..197f4e84dfc76ff264e7aa1845f35eb3b6f86a20
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Invalid left-hand side in 'For[In/Of]Statement' [test-for-3.js:17:14]
diff --git a/es2panda/test/parser/js/test-for-3.js b/es2panda/test/parser/js/test-for-3.js
new file mode 100644
index 0000000000000000000000000000000000000000..b5b575a0ba39f45b189589080727ebdec78d86ec
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-3.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+for (a<b in a) {}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-for-4-expected.txt b/es2panda/test/parser/js/test-for-4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..39aa4e91fd23508f721170bea4c970e1fb50aad9
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected ';' in 'ForStatement'. [test-for-4.js:17:17]
diff --git a/es2panda/test/parser/js/test-for-4.js b/es2panda/test/parser/js/test-for-4.js
new file mode 100644
index 0000000000000000000000000000000000000000..c54e3d54749ff19ce0e553f6081a59fb24c06bf5
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-4.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+for (let d,c of {d,c});
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-for-expected.txt b/es2panda/test/parser/js/test-for-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..00e636fc8ad5c29ca5d0fb38de435321959d8932
--- /dev/null
+++ b/es2panda/test/parser/js/test-for-expected.txt
@@ -0,0 +1,1818 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ForUpdateStatement",
+      "init": null,
+      "test": null,
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 8
+          },
+          "end": {
+            "line": 17,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": null,
+      "test": null,
+      "update": null,
+      "body": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 8
+          },
+          "end": {
+            "line": 19,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "BinaryExpression",
+        "operator": "<",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 7
+            },
+            "end": {
+              "line": 21,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 5
+          },
+          "end": {
+            "line": 21,
+            "column": 8
+          }
+        }
+      },
+      "test": null,
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 11
+          },
+          "end": {
+            "line": 21,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "BinaryExpression",
+        "operator": "<",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 5
+            },
+            "end": {
+              "line": 23,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 7
+            },
+            "end": {
+              "line": 23,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 5
+          },
+          "end": {
+            "line": 23,
+            "column": 8
+          }
+        }
+      },
+      "test": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 9
+            },
+            "end": {
+              "line": 23,
+              "column": 10
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 9
+          },
+          "end": {
+            "line": 23,
+            "column": 12
+          }
+        }
+      },
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 14
+          },
+          "end": {
+            "line": 23,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "BinaryExpression",
+        "operator": "<",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 7
+            },
+            "end": {
+              "line": 25,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 5
+          },
+          "end": {
+            "line": 25,
+            "column": 8
+          }
+        }
+      },
+      "test": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 9
+            },
+            "end": {
+              "line": 25,
+              "column": 10
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 9
+          },
+          "end": {
+            "line": 25,
+            "column": 12
+          }
+        }
+      },
+      "update": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 13
+            },
+            "end": {
+              "line": 25,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 13
+          },
+          "end": {
+            "line": 25,
+            "column": 16
+          }
+        }
+      },
+      "body": {
+        "type": "BlockStatement",
+        "statements": [
+          {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "Identifier",
+              "name": "AnimationPlaybackEvent",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 18
+                },
+                "end": {
+                  "line": 25,
+                  "column": 40
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 18
+              },
+              "end": {
+                "line": 25,
+                "column": 41
+              }
+            }
+          },
+          {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "Identifier",
+              "name": "fetch",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 42
+                },
+                "end": {
+                  "line": 25,
+                  "column": 47
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 42
+              },
+              "end": {
+                "line": 25,
+                "column": 48
+              }
+            }
+          },
+          {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "CallExpression",
+              "callee": {
+                "type": "ArrayExpression",
+                "elements": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 50
+                  }
+                }
+              },
+              "arguments": [],
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 48
+                },
+                "end": {
+                  "line": 25,
+                  "column": 52
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 48
+              },
+              "end": {
+                "line": 25,
+                "column": 52
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 17
+          },
+          "end": {
+            "line": 25,
+            "column": 53
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 53
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "FunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": false,
+            "params": [],
+            "body": {
+              "type": "BlockStatement",
+              "statements": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 16
+                },
+                "end": {
+                  "line": 27,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 6
+              },
+              "end": {
+                "line": 27,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 5
+            },
+            "end": {
+              "line": 27,
+              "column": 19
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 5
+          },
+          "end": {
+            "line": 27,
+            "column": 21
+          }
+        }
+      },
+      "test": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "FunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": false,
+            "params": [],
+            "body": {
+              "type": "BlockStatement",
+              "statements": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 34
+                },
+                "end": {
+                  "line": 27,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 24
+              },
+              "end": {
+                "line": 27,
+                "column": 36
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 23
+            },
+            "end": {
+              "line": 27,
+              "column": 37
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 23
+          },
+          "end": {
+            "line": 27,
+            "column": 39
+          }
+        }
+      },
+      "update": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "FunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": false,
+            "params": [],
+            "body": {
+              "type": "BlockStatement",
+              "statements": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 52
+                },
+                "end": {
+                  "line": 27,
+                  "column": 54
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 42
+              },
+              "end": {
+                "line": 27,
+                "column": 54
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 41
+            },
+            "end": {
+              "line": 27,
+              "column": 55
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 41
+          },
+          "end": {
+            "line": 27,
+            "column": 57
+          }
+        }
+      },
+      "body": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 59
+          },
+          "end": {
+            "line": 27,
+            "column": 61
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": null,
+      "test": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 7
+          },
+          "end": {
+            "line": 29,
+            "column": 8
+          }
+        }
+      },
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 10
+          },
+          "end": {
+            "line": 29,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": null,
+      "test": null,
+      "update": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 8
+          },
+          "end": {
+            "line": 30,
+            "column": 9
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 10
+          },
+          "end": {
+            "line": 30,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "fa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 10
+                },
+                "end": {
+                  "line": 32,
+                  "column": 12
+                }
+              }
+            },
+            "init": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 15
+                },
+                "end": {
+                  "line": 32,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 10
+              },
+              "end": {
+                "line": 32,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 6
+          },
+          "end": {
+            "line": 32,
+            "column": 16
+          }
+        }
+      },
+      "test": null,
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 19
+          },
+          "end": {
+            "line": 32,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "faa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 10
+                },
+                "end": {
+                  "line": 33,
+                  "column": 13
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 10
+              },
+              "end": {
+                "line": 33,
+                "column": 13
+              }
+            }
+          },
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "baa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 14
+                },
+                "end": {
+                  "line": 33,
+                  "column": 17
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 14
+              },
+              "end": {
+                "line": 33,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "caa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 18
+                },
+                "end": {
+                  "line": 33,
+                  "column": 21
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 18
+              },
+              "end": {
+                "line": 33,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 6
+          },
+          "end": {
+            "line": 33,
+            "column": 21
+          }
+        }
+      },
+      "test": null,
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 25
+          },
+          "end": {
+            "line": 33,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "faaa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 10
+                },
+                "end": {
+                  "line": 34,
+                  "column": 14
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 10
+              },
+              "end": {
+                "line": 34,
+                "column": 14
+              }
+            }
+          },
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "baaa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 15
+                },
+                "end": {
+                  "line": 34,
+                  "column": 19
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 15
+              },
+              "end": {
+                "line": 34,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "caaa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 20
+                },
+                "end": {
+                  "line": 34,
+                  "column": 24
+                }
+              }
+            },
+            "init": {
+              "type": "NumberLiteral",
+              "value": 6,
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 27
+                },
+                "end": {
+                  "line": 34,
+                  "column": 28
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 20
+              },
+              "end": {
+                "line": 34,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 6
+          },
+          "end": {
+            "line": 34,
+            "column": 28
+          }
+        }
+      },
+      "test": null,
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 31
+          },
+          "end": {
+            "line": 34,
+            "column": 32
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "sa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 10
+                },
+                "end": {
+                  "line": 35,
+                  "column": 12
+                }
+              }
+            },
+            "init": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 15
+                },
+                "end": {
+                  "line": 35,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 10
+              },
+              "end": {
+                "line": 35,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 35,
+            "column": 6
+          },
+          "end": {
+            "line": 35,
+            "column": 16
+          }
+        }
+      },
+      "test": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 17
+            },
+            "end": {
+              "line": 35,
+              "column": 18
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 35,
+            "column": 17
+          },
+          "end": {
+            "line": 35,
+            "column": 20
+          }
+        }
+      },
+      "update": null,
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 35,
+            "column": 22
+          },
+          "end": {
+            "line": 35,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ForUpdateStatement",
+      "init": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "ba",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 10
+                },
+                "end": {
+                  "line": 36,
+                  "column": 12
+                }
+              }
+            },
+            "init": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 15
+                },
+                "end": {
+                  "line": 36,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 10
+              },
+              "end": {
+                "line": 36,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 6
+          },
+          "end": {
+            "line": 36,
+            "column": 16
+          }
+        }
+      },
+      "test": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 17
+            },
+            "end": {
+              "line": 36,
+              "column": 18
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 17
+          },
+          "end": {
+            "line": 36,
+            "column": 20
+          }
+        }
+      },
+      "update": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "ArrayExpression",
+          "elements": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 21
+            },
+            "end": {
+              "line": 36,
+              "column": 23
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 21
+          },
+          "end": {
+            "line": 36,
+            "column": 25
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 26
+          },
+          "end": {
+            "line": 36,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ForInStatement",
+      "left": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 5
+          },
+          "end": {
+            "line": 37,
+            "column": 6
+          }
+        }
+      },
+      "right": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 10
+          },
+          "end": {
+            "line": 37,
+            "column": 11
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 12
+          },
+          "end": {
+            "line": 37,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ForOfStatement",
+      "await": false,
+      "left": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 5
+          },
+          "end": {
+            "line": 38,
+            "column": 6
+          }
+        }
+      },
+      "right": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 10
+          },
+          "end": {
+            "line": 38,
+            "column": 11
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 12
+          },
+          "end": {
+            "line": 38,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ForInStatement",
+      "left": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "caaaa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 9
+                },
+                "end": {
+                  "line": 39,
+                  "column": 14
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 9
+              },
+              "end": {
+                "line": 39,
+                "column": 14
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 39,
+            "column": 5
+          },
+          "end": {
+            "line": 39,
+            "column": 14
+          }
+        }
+      },
+      "right": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 39,
+            "column": 18
+          },
+          "end": {
+            "line": 39,
+            "column": 19
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 39,
+            "column": 20
+          },
+          "end": {
+            "line": 39,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 39,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ForOfStatement",
+      "await": false,
+      "left": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "cdaaaad",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 9
+                },
+                "end": {
+                  "line": 40,
+                  "column": 16
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 9
+              },
+              "end": {
+                "line": 40,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 5
+          },
+          "end": {
+            "line": 40,
+            "column": 16
+          }
+        }
+      },
+      "right": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 20
+          },
+          "end": {
+            "line": 40,
+            "column": 21
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 22
+          },
+          "end": {
+            "line": 40,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ForInStatement",
+      "left": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "cdaaaay",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 9
+                },
+                "end": {
+                  "line": 41,
+                  "column": 16
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 9
+              },
+              "end": {
+                "line": 41,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "kind": "let",
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 5
+          },
+          "end": {
+            "line": 41,
+            "column": 16
+          }
+        }
+      },
+      "right": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 20
+          },
+          "end": {
+            "line": 41,
+            "column": 21
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 22
+          },
+          "end": {
+            "line": 41,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ForOfStatement",
+      "await": false,
+      "left": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 44,
+            "column": 3
+          },
+          "end": {
+            "line": 44,
+            "column": 4
+          }
+        }
+      },
+      "right": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 46,
+            "column": 3
+          },
+          "end": {
+            "line": 46,
+            "column": 4
+          }
+        }
+      },
+      "body": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 47,
+            "column": 2
+          },
+          "end": {
+            "line": 47,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 47,
+          "column": 3
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 49,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-for.js b/es2panda/test/parser/js/test-for.js
new file mode 100644
index 0000000000000000000000000000000000000000..1e1eb20a7e85bb2e54fc7b3605fadd18b7c7fadb
--- /dev/null
+++ b/es2panda/test/parser/js/test-for.js
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+for(;;);
+
+for(;;){}
+
+for(a<b;;);
+
+for(a<b;c(););
+
+for(a<b;c();a++){AnimationPlaybackEvent; fetch;[]()}
+
+for((function(){})(); (function(){})(); (function(){})()) {}
+
+for (;a;);
+for (;;a);
+
+for (let fa = 5;;);
+for (let faa,baa,caa ;;);
+for (let faaa,baaa,caaa = 6;;);
+for (let sa = 5;a(););
+for (let ba = 5;a();[]());
+for(a in b);
+for(a of b);
+for(let caaaa in b);
+for(let cdaaaad of b);
+for(let cdaaaay in b);
+for 
+(
+  a
+  of
+  b
+);
+
diff --git a/es2panda/test/parser/js/test-function-decl-expected.txt b/es2panda/test/parser/js/test-function-decl-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6134e1f20e204eeb903c47758cad2f86525af075
--- /dev/null
+++ b/es2panda/test/parser/js/test-function-decl-expected.txt
@@ -0,0 +1,659 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 7
+              }
+            }
+          },
+          "init": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "ExpressionStatement",
+                    "expression": {
+                      "type": "StringLiteral",
+                      "value": "asd",
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 28
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 28
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 30
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 10
+                },
+                "end": {
+                  "line": 17,
+                  "column": 30
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 10
+              },
+              "end": {
+                "line": 17,
+                "column": 30
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 30
+            }
+          }
+        },
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f10",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 32
+              },
+              "end": {
+                "line": 17,
+                "column": 35
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 32
+            },
+            "end": {
+              "line": 17,
+              "column": 35
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "f2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 3
+            }
+          }
+        },
+        "right": {
+          "type": "FunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": false,
+            "params": [],
+            "body": {
+              "type": "BlockStatement",
+              "statements": [
+                {
+                  "type": "ReturnStatement",
+                  "argument": {
+                    "type": "NumberLiteral",
+                    "value": 123,
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 13
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 6
+              },
+              "end": {
+                "line": 20,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 6
+            },
+            "end": {
+              "line": 20,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "f3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 3
+            }
+          }
+        },
+        "right": {
+          "type": "FunctionExpression",
+          "function": {
+            "type": "ScriptFunction",
+            "id": null,
+            "generator": false,
+            "async": false,
+            "expression": false,
+            "params": [],
+            "body": {
+              "type": "BlockStatement",
+              "statements": [
+                {
+                  "type": "ReturnStatement",
+                  "argument": {
+                    "type": "NumberLiteral",
+                    "value": 123,
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 1
+                },
+                "end": {
+                  "line": 25,
+                  "column": 2
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 6
+              },
+              "end": {
+                "line": 25,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 6
+            },
+            "end": {
+              "line": 25,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 5
+              },
+              "end": {
+                "line": 27,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 5
+            },
+            "end": {
+              "line": 27,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "f4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 10
+            },
+            "end": {
+              "line": 29,
+              "column": 12
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 13
+              },
+              "end": {
+                "line": 29,
+                "column": 14
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 16
+              },
+              "end": {
+                "line": 29,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 19
+              },
+              "end": {
+                "line": 29,
+                "column": 20
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "VariableDeclaration",
+              "declarations": [
+                {
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 8
+                      }
+                    }
+                  },
+                  "init": null,
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 8
+                    }
+                  }
+                }
+              ],
+              "kind": "let",
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 3
+                },
+                "end": {
+                  "line": 30,
+                  "column": 9
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 22
+            },
+            "end": {
+              "line": 31,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 31,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "await",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 16
+            },
+            "end": {
+              "line": 33,
+              "column": 21
+            }
+          }
+        },
+        "generator": false,
+        "async": true,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 24
+            },
+            "end": {
+              "line": 33,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 7
+          },
+          "end": {
+            "line": 33,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 27
+        },
+        "end": {
+          "line": 33,
+          "column": 28
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 33,
+      "column": 28
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-function-decl.js b/es2panda/test/parser/js/test-function-decl.js
new file mode 100644
index 0000000000000000000000000000000000000000..ae07840465efd1b8e6f732a342da2306dd18905f
--- /dev/null
+++ b/es2panda/test/parser/js/test-function-decl.js
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var f1 = function() { "asd" }, f10
+;
+f2 = function() {
+  return 123 }
+
+f3 = function()
+{
+  return 123;
+}
+
+let d;
+
+function f4(a, b, c) {
+  let d;
+}
+
+async function await() { };
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-function-scope-violation-1-expected.txt b/es2panda/test/parser/js/test-function-scope-violation-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..adb7e2d7edebc255c91dc4988616fcac0ed683b7
--- /dev/null
+++ b/es2panda/test/parser/js/test-function-scope-violation-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Variable 'a' has already been declared. [test-function-scope-violation-1.js:21:7]
diff --git a/es2panda/test/parser/js/test-function-scope-violation-1.js b/es2panda/test/parser/js/test-function-scope-violation-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..aab672486b439a10456895882cad9b36dc8ec469
--- /dev/null
+++ b/es2panda/test/parser/js/test-function-scope-violation-1.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let d;
+
+function f(a, b, c) {
+  let d;
+  let a;
+}
diff --git a/es2panda/test/parser/js/test-function-scope-violation-2-expected.txt b/es2panda/test/parser/js/test-function-scope-violation-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ed91d863a10057508595c25f42e9eb44fa10ac0b
--- /dev/null
+++ b/es2panda/test/parser/js/test-function-scope-violation-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Variable 'c' has already been declared. [test-function-scope-violation-2.js:20:9]
diff --git a/es2panda/test/parser/js/test-function-scope-violation-2.js b/es2panda/test/parser/js/test-function-scope-violation-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f1666a865edf0fbf1c8dcea25da714c727e9566
--- /dev/null
+++ b/es2panda/test/parser/js/test-function-scope-violation-2.js
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let c;
+
+function f(a, b, c) {
+  const c = 1;
+}
diff --git a/es2panda/test/parser/js/test-grouping-level-expected.txt b/es2panda/test/parser/js/test-grouping-level-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..26af2874d15257c8855daa7ec7f869c55c69eed1
--- /dev/null
+++ b/es2panda/test/parser/js/test-grouping-level-expected.txt
@@ -0,0 +1,1025 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 2
+            },
+            "end": {
+              "line": 17,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "*",
+          "left": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 10
+              },
+              "end": {
+                "line": 17,
+                "column": 11
+              }
+            }
+          },
+          "right": {
+            "type": "BinaryExpression",
+            "operator": "+",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 15
+                },
+                "end": {
+                  "line": 17,
+                  "column": 16
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 17
+                },
+                "end": {
+                  "line": 17,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 14
+              },
+              "end": {
+                "line": 17,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 9
+            },
+            "end": {
+              "line": 17,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "/",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": "*",
+          "left": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 2
+                },
+                "end": {
+                  "line": 18,
+                  "column": 5
+                }
+              }
+            },
+            "right": {
+              "type": "LogicalExpression",
+              "operator": "||",
+              "left": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 8
+                  }
+                }
+              },
+              "right": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 6
+                },
+                "end": {
+                  "line": 18,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 1
+              },
+              "end": {
+                "line": 18,
+                "column": 15
+              }
+            }
+          },
+          "right": {
+            "type": "BinaryExpression",
+            "operator": "-",
+            "left": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 19
+                },
+                "end": {
+                  "line": 18,
+                  "column": 20
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 21
+                },
+                "end": {
+                  "line": 18,
+                  "column": 22
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 18
+              },
+              "end": {
+                "line": 18,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 23
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 26
+            },
+            "end": {
+              "line": 18,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": "/",
+          "left": {
+            "type": "BinaryExpression",
+            "operator": "+",
+            "left": {
+              "type": "BinaryExpression",
+              "operator": "*",
+              "left": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 3
+                  }
+                }
+              },
+              "right": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 5
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 2
+                },
+                "end": {
+                  "line": 19,
+                  "column": 5
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 6
+                },
+                "end": {
+                  "line": 19,
+                  "column": 7
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 8
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 9
+              },
+              "end": {
+                "line": 19,
+                "column": 12
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 12
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 13
+            },
+            "end": {
+              "line": 19,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "%",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": "*",
+          "left": {
+            "type": "BinaryExpression",
+            "operator": "+",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 3
+                },
+                "end": {
+                  "line": 20,
+                  "column": 4
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 5
+                },
+                "end": {
+                  "line": 20,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 2
+              },
+              "end": {
+                "line": 20,
+                "column": 7
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 10
+              },
+              "end": {
+                "line": 20,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 16
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "+",
+          "left": {
+            "type": "Identifier",
+            "name": "e",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 20
+              },
+              "end": {
+                "line": 20,
+                "column": 25
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "f",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 27
+              },
+              "end": {
+                "line": 20,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 19
+            },
+            "end": {
+              "line": 20,
+              "column": 29
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "BinaryExpression",
+          "operator": "+",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 2
+              },
+              "end": {
+                "line": 21,
+                "column": 7
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 3
+              },
+              "end": {
+                "line": 22,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 7
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "prefix": false,
+            "argument": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 2
+                },
+                "end": {
+                  "line": 23,
+                  "column": 5
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 2
+              },
+              "end": {
+                "line": 23,
+                "column": 7
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": true,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 3
+            },
+            "end": {
+              "line": 24,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "UnaryExpression",
+          "operator": "!",
+          "prefix": true,
+          "argument": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 2
+              },
+              "end": {
+                "line": 25,
+                "column": 3
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 3
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 7
+            },
+            "end": {
+              "line": 25,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "!",
+        "prefix": true,
+        "argument": {
+          "type": "UnaryExpression",
+          "operator": "!",
+          "prefix": true,
+          "argument": {
+            "type": "LogicalExpression",
+            "operator": "||",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 7
+                },
+                "end": {
+                  "line": 26,
+                  "column": 8
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 12
+                },
+                "end": {
+                  "line": 26,
+                  "column": 13
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 4
+              },
+              "end": {
+                "line": 26,
+                "column": 16
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 2
+            },
+            "end": {
+              "line": 26,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": {
+            "type": "LogicalExpression",
+            "operator": "||",
+            "left": {
+              "type": "UpdateExpression",
+              "operator": "++",
+              "prefix": true,
+              "argument": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 7
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 2
+                },
+                "end": {
+                  "line": 27,
+                  "column": 7
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 11
+                },
+                "end": {
+                  "line": 27,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 1
+              },
+              "end": {
+                "line": 27,
+                "column": 13
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 17
+              },
+              "end": {
+                "line": 27,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 18
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 22
+            },
+            "end": {
+              "line": 27,
+              "column": 23
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 23
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 23
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 27,
+      "column": 23
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-grouping-level.js b/es2panda/test/parser/js/test-grouping-level.js
new file mode 100644
index 0000000000000000000000000000000000000000..d9f9a1ba421733847be787e95ded55ed506c8069
--- /dev/null
+++ b/es2panda/test/parser/js/test-grouping-level.js
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+((a) && (b * (c+d)));
+((a)=(b || c)) * (d-c) / 2;
+(a*b+c)/(d)-e;
+((a+b) * ((c))) % (((e))+ f);
+(((a))
++ (b))
+((a)++)
+++((a))
+!a || b
+!(!(((a || b))));
+(++(a) || b) && d || c
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-if-1-expected.txt b/es2panda/test/parser/js/test-if-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..86e03d23c0d108f4c5a321222a396dd5d483d3a8
--- /dev/null
+++ b/es2panda/test/parser/js/test-if-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Missing left parenthesis in an 'IfStatement' [test-if-1.js:17:4]
diff --git a/es2panda/test/parser/js/test-if-1.js b/es2panda/test/parser/js/test-if-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..6243f71f2b645b333bfe0dbeda28c631cda8fc11
--- /dev/null
+++ b/es2panda/test/parser/js/test-if-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+if else;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-if-2-expected.txt b/es2panda/test/parser/js/test-if-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d2e0438a2100760beaae57027f78bdfedfab80e1
--- /dev/null
+++ b/es2panda/test/parser/js/test-if-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-if-2.js:17:4]
diff --git a/es2panda/test/parser/js/test-if-2.js b/es2panda/test/parser/js/test-if-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..b2528458d7ec0d744b50f7b17a971d740f6157a0
--- /dev/null
+++ b/es2panda/test/parser/js/test-if-2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+if()
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-if-expected.txt b/es2panda/test/parser/js/test-if-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cb2b29bc5ef7715b901fae4610dc1ee25337e9b3
--- /dev/null
+++ b/es2panda/test/parser/js/test-if-expected.txt
@@ -0,0 +1,887 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "UnaryExpression",
+        "operator": "!",
+        "prefix": true,
+        "argument": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 4
+          },
+          "end": {
+            "line": 17,
+            "column": 8
+          }
+        }
+      },
+      "consequent": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "alma",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 2
+              },
+              "end": {
+                "line": 18,
+                "column": 6
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 9
+              },
+              "end": {
+                "line": 18,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 2
+            },
+            "end": {
+              "line": 18,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 2
+          },
+          "end": {
+            "line": 18,
+            "column": 10
+          }
+        }
+      },
+      "alternate": null,
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "NumberLiteral",
+        "value": 1,
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 4
+          },
+          "end": {
+            "line": 20,
+            "column": 5
+          }
+        }
+      },
+      "consequent": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "fa",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 7
+              },
+              "end": {
+                "line": 20,
+                "column": 9
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 12
+              },
+              "end": {
+                "line": 20,
+                "column": 13
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 7
+          },
+          "end": {
+            "line": 20,
+            "column": 13
+          }
+        }
+      },
+      "alternate": null,
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "NumberLiteral",
+        "value": 0,
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 4
+          },
+          "end": {
+            "line": 22,
+            "column": 5
+          }
+        }
+      },
+      "consequent": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "alma",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 7
+              },
+              "end": {
+                "line": 22,
+                "column": 11
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 14
+              },
+              "end": {
+                "line": 22,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 7
+            },
+            "end": {
+              "line": 22,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 7
+          },
+          "end": {
+            "line": 22,
+            "column": 16
+          }
+        }
+      },
+      "alternate": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "fa",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 22
+              },
+              "end": {
+                "line": 22,
+                "column": 24
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 27
+              },
+              "end": {
+                "line": 22,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 22
+            },
+            "end": {
+              "line": 22,
+              "column": 28
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 22
+          },
+          "end": {
+            "line": 22,
+            "column": 28
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "NumberLiteral",
+        "value": 0,
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 4
+          },
+          "end": {
+            "line": 24,
+            "column": 5
+          }
+        }
+      },
+      "consequent": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "alma",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 3
+              },
+              "end": {
+                "line": 25,
+                "column": 7
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 10
+              },
+              "end": {
+                "line": 25,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 3
+            },
+            "end": {
+              "line": 25,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 3
+          },
+          "end": {
+            "line": 25,
+            "column": 12
+          }
+        }
+      },
+      "alternate": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "fa",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 6
+              },
+              "end": {
+                "line": 26,
+                "column": 8
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 11
+              },
+              "end": {
+                "line": 26,
+                "column": 12
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 6
+            },
+            "end": {
+              "line": 26,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 6
+          },
+          "end": {
+            "line": 26,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "NumberLiteral",
+        "value": 0,
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 4
+          },
+          "end": {
+            "line": 28,
+            "column": 5
+          }
+        }
+      },
+      "consequent": {
+        "type": "BlockStatement",
+        "statements": [
+          {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "alma",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 12
+                  }
+                }
+              },
+              "right": {
+                "type": "NumberLiteral",
+                "value": 0,
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 8
+                },
+                "end": {
+                  "line": 28,
+                  "column": 16
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 8
+              },
+              "end": {
+                "line": 28,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 7
+          },
+          "end": {
+            "line": 28,
+            "column": 17
+          }
+        }
+      },
+      "alternate": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "Identifier",
+            "name": "fa",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 23
+              },
+              "end": {
+                "line": 28,
+                "column": 25
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 28
+              },
+              "end": {
+                "line": 28,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 23
+            },
+            "end": {
+              "line": 28,
+              "column": 29
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 23
+          },
+          "end": {
+            "line": 28,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "NumberLiteral",
+        "value": 0,
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 5
+          },
+          "end": {
+            "line": 30,
+            "column": 6
+          }
+        }
+      },
+      "consequent": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 30,
+            "column": 7
+          },
+          "end": {
+            "line": 30,
+            "column": 8
+          }
+        }
+      },
+      "alternate": {
+        "type": "IfStatement",
+        "test": {
+          "type": "StringLiteral",
+          "value": "alma",
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 4
+            },
+            "end": {
+              "line": 32,
+              "column": 10
+            }
+          }
+        },
+        "consequent": {
+          "type": "EmptyStatement",
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 11
+            },
+            "end": {
+              "line": 32,
+              "column": 12
+            }
+          }
+        },
+        "alternate": null,
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 1
+          },
+          "end": {
+            "line": 32,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "NumberLiteral",
+        "value": 0,
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 4
+          },
+          "end": {
+            "line": 34,
+            "column": 5
+          }
+        }
+      },
+      "consequent": {
+        "type": "EmptyStatement",
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 6
+          },
+          "end": {
+            "line": 34,
+            "column": 7
+          }
+        }
+      },
+      "alternate": {
+        "type": "IfStatement",
+        "test": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 16
+            },
+            "end": {
+              "line": 34,
+              "column": 17
+            }
+          }
+        },
+        "consequent": {
+          "type": "EmptyStatement",
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 19
+            },
+            "end": {
+              "line": 34,
+              "column": 20
+            }
+          }
+        },
+        "alternate": {
+          "type": "IfStatement",
+          "test": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 28
+              },
+              "end": {
+                "line": 34,
+                "column": 29
+              }
+            }
+          },
+          "consequent": {
+            "type": "ExpressionStatement",
+            "expression": {
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "alma",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 35
+                  }
+                }
+              },
+              "right": {
+                "type": "StringLiteral",
+                "value": "fa",
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 42
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 31
+                },
+                "end": {
+                  "line": 34,
+                  "column": 42
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 31
+              },
+              "end": {
+                "line": 34,
+                "column": 43
+              }
+            }
+          },
+          "alternate": {
+            "type": "EmptyStatement",
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 48
+              },
+              "end": {
+                "line": 34,
+                "column": 49
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 25
+            },
+            "end": {
+              "line": 34,
+              "column": 49
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 13
+          },
+          "end": {
+            "line": 34,
+            "column": 49
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 49
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 34,
+      "column": 49
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-if.js b/es2panda/test/parser/js/test-if.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd8b356f70594d34ac75338817ad84dbc8d78c10
--- /dev/null
+++ b/es2panda/test/parser/js/test-if.js
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+if(!(1))
+	alma = 0
+
+if(1) fa = 1
+
+if(0) alma = 0; else fa = 1
+
+if(0)
+  alma = 0;
+else fa = 1
+
+if(0) {alma = 0} else fa = 1
+
+if (0);else
+ 
+if('alma');
+
+if(0); else if(0) ;else if(1) alma = 'fa'; else;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-import-decl-expected.txt b/es2panda/test/parser/js/test-import-decl-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8113f3cc0ca13570f3f4f264cc29aab7b76cd78d
--- /dev/null
+++ b/es2panda/test/parser/js/test-import-decl-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'import' and 'export' may appear only with 'sourceType: module' [test-import-decl.js:21:1]
diff --git a/es2panda/test/parser/js/test-import-decl.js b/es2panda/test/parser/js/test-import-decl.js
new file mode 100644
index 0000000000000000000000000000000000000000..b0234c915355e3051a5237e83bef8a0e73be52dd
--- /dev/null
+++ b/es2panda/test/parser/js/test-import-decl.js
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*---
+flags: [module]
+---*/
+
+import * as b from "foo"
+import a from "bar";
+import {c, d as e, f } from "bar"
+import "foobar";
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-import-expression-expected.txt b/es2panda/test/parser/js/test-import-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e74e061c9b92871cd5ceff8194556115bd2be1d6
--- /dev/null
+++ b/es2panda/test/parser/js/test-import-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'import' and 'export' may appear only with 'sourceType: module' [test-import-expression.js:20:1]
diff --git a/es2panda/test/parser/js/test-import-expression.js b/es2panda/test/parser/js/test-import-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..accb0bcbd40a4206baab6e196477e5f2de6b429b
--- /dev/null
+++ b/es2panda/test/parser/js/test-import-expression.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*---
+flags: [module]
+---*/
+
+import("foo")
+var a = import("bar");
+import "foobar";
diff --git a/es2panda/test/parser/js/test-import-meta-expected.txt b/es2panda/test/parser/js/test-import-meta-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3fa3cb7b2f806fea010263711651ea482bf420e2
--- /dev/null
+++ b/es2panda/test/parser/js/test-import-meta-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'import' and 'export' may appear only with 'sourceType: module' [test-import-meta.js:21:1]
diff --git a/es2panda/test/parser/js/test-import-meta.js b/es2panda/test/parser/js/test-import-meta.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1a6633a4d6eef723837ebde8e717687cb287205
--- /dev/null
+++ b/es2panda/test/parser/js/test-import-meta.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*---
+flags: [module]
+---*/
+
+import(import.meta)
+import.meta
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-imported-decl1-expected.txt b/es2panda/test/parser/js/test-imported-decl1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53aa6a5ff40aac0ca8e6a64ffef402e8af06ae1f
--- /dev/null
+++ b/es2panda/test/parser/js/test-imported-decl1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'import' and 'export' may appear only with 'sourceType: module' [test-imported-decl1.js:21:1]
diff --git a/es2panda/test/parser/js/test-imported-decl1.js b/es2panda/test/parser/js/test-imported-decl1.js
new file mode 100644
index 0000000000000000000000000000000000000000..08e915c727e8b33f11c7af3e568decfd00541166
--- /dev/null
+++ b/es2panda/test/parser/js/test-imported-decl1.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/*---
+flags: [module]
+---*/
+
+import * as b from "foo"
+import b from "bar"
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-labelled-statement-expected.txt b/es2panda/test/parser/js/test-labelled-statement-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ddeee219715e1ea14cb6ec49a229908c41de2bf5
--- /dev/null
+++ b/es2panda/test/parser/js/test-labelled-statement-expected.txt
@@ -0,0 +1,1276 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 4
+            },
+            "end": {
+              "line": 17,
+              "column": 5
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 4
+          },
+          "end": {
+            "line": 17,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "b",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "IfStatement",
+        "test": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 8
+            },
+            "end": {
+              "line": 19,
+              "column": 9
+            }
+          }
+        },
+        "consequent": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 11
+            },
+            "end": {
+              "line": 19,
+              "column": 13
+            }
+          }
+        },
+        "alternate": null,
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 4
+          },
+          "end": {
+            "line": 19,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "c",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "IfStatement",
+        "test": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 8
+            },
+            "end": {
+              "line": 21,
+              "column": 9
+            }
+          }
+        },
+        "consequent": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 11
+            },
+            "end": {
+              "line": 21,
+              "column": 13
+            }
+          }
+        },
+        "alternate": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 19
+            },
+            "end": {
+              "line": 21,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 4
+          },
+          "end": {
+            "line": 21,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "d",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "WhileStatement",
+        "test": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 11
+            },
+            "end": {
+              "line": 23,
+              "column": 12
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 14
+            },
+            "end": {
+              "line": 23,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 4
+          },
+          "end": {
+            "line": 23,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 16
+        },
+        "end": {
+          "line": 23,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "e",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "DoWhileStatement",
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 7
+            },
+            "end": {
+              "line": 25,
+              "column": 9
+            }
+          }
+        },
+        "test": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 17
+            },
+            "end": {
+              "line": 25,
+              "column": 18
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 4
+          },
+          "end": {
+            "line": 25,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "f",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "SwitchStatement",
+        "discriminant": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 11
+            },
+            "end": {
+              "line": 27,
+              "column": 12
+            }
+          }
+        },
+        "cases": [],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 4
+          },
+          "end": {
+            "line": 27,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "g",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "TryStatement",
+        "block": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 8
+            },
+            "end": {
+              "line": 29,
+              "column": 10
+            }
+          }
+        },
+        "handler": {
+          "type": "CatchClause",
+          "body": {
+            "type": "BlockStatement",
+            "statements": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 20
+              },
+              "end": {
+                "line": 29,
+                "column": 22
+              }
+            }
+          },
+          "param": {
+            "type": "Identifier",
+            "name": "e",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 17
+              },
+              "end": {
+                "line": 29,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 11
+            },
+            "end": {
+              "line": 29,
+              "column": 22
+            }
+          }
+        },
+        "finalizer": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 31
+            },
+            "end": {
+              "line": 29,
+              "column": 33
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 4
+          },
+          "end": {
+            "line": 29,
+            "column": 33
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 10
+            },
+            "end": {
+              "line": 31,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "LabelledStatement",
+              "label": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 4
+                  }
+                }
+              },
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "LabelledStatement",
+                    "label": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "WhileStatement",
+                      "test": {
+                        "type": "BooleanLiteral",
+                        "value": true,
+                        "loc": {
+                          "start": {
+                            "line": 36,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 36,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "body": {
+                        "type": "BlockStatement",
+                        "statements": [
+                          {
+                            "type": "BreakStatement",
+                            "label": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 38,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 38,
+                                  "column": 14
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 38,
+                                "column": 7
+                              },
+                              "end": {
+                                "line": 38,
+                                "column": 15
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 37,
+                            "column": 5
+                          },
+                          "end": {
+                            "line": 39,
+                            "column": 6
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 39,
+                        "column": 6
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 4
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 3
+                },
+                "end": {
+                  "line": 40,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 1
+            },
+            "end": {
+              "line": 41,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 31,
+            "column": 1
+          },
+          "end": {
+            "line": 41,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 44,
+              "column": 10
+            },
+            "end": {
+              "line": 44,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "LabelledStatement",
+              "label": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 4
+                  }
+                }
+              },
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "LabelledStatement",
+                    "label": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 48,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 48,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "LabelledStatement",
+                      "label": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 5
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 6
+                          }
+                        }
+                      },
+                      "body": {
+                        "type": "WhileStatement",
+                        "test": {
+                          "type": "BooleanLiteral",
+                          "value": true,
+                          "loc": {
+                            "start": {
+                              "line": 50,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 50,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "body": {
+                          "type": "BlockStatement",
+                          "statements": [
+                            {
+                              "type": "BreakStatement",
+                              "label": {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 52,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 52,
+                                    "column": 14
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 52,
+                                  "column": 7
+                                },
+                                "end": {
+                                  "line": 52,
+                                  "column": 15
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 51,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 53,
+                              "column": 6
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 50,
+                            "column": 5
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 6
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 49,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 6
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 48,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 53,
+                        "column": 6
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 47,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 4
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 3
+                },
+                "end": {
+                  "line": 54,
+                  "column": 4
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 1
+            },
+            "end": {
+              "line": 55,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 44,
+            "column": 1
+          },
+          "end": {
+            "line": 55,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 44,
+          "column": 1
+        },
+        "end": {
+          "line": 55,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 57,
+            "column": 1
+          },
+          "end": {
+            "line": 57,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "LabelledStatement",
+        "label": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 1
+            },
+            "end": {
+              "line": 58,
+              "column": 2
+            }
+          }
+        },
+        "body": {
+          "type": "LabelledStatement",
+          "label": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 59,
+                "column": 1
+              },
+              "end": {
+                "line": 59,
+                "column": 2
+              }
+            }
+          },
+          "body": {
+            "type": "LabelledStatement",
+            "label": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 1
+                },
+                "end": {
+                  "line": 60,
+                  "column": 2
+                }
+              }
+            },
+            "body": {
+              "type": "ExpressionStatement",
+              "expression": {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 5
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 4
+                },
+                "end": {
+                  "line": 60,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 60,
+                "column": 1
+              },
+              "end": {
+                "line": 60,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 59,
+              "column": 1
+            },
+            "end": {
+              "line": 60,
+              "column": 6
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 58,
+            "column": 1
+          },
+          "end": {
+            "line": 60,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 60,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 62,
+            "column": 1
+          },
+          "end": {
+            "line": 62,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 62,
+              "column": 4
+            },
+            "end": {
+              "line": 62,
+              "column": 5
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 62,
+            "column": 4
+          },
+          "end": {
+            "line": 62,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 62,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 63,
+            "column": 1
+          },
+          "end": {
+            "line": 63,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 63,
+              "column": 4
+            },
+            "end": {
+              "line": 63,
+              "column": 5
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 63,
+            "column": 4
+          },
+          "end": {
+            "line": 63,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 63,
+          "column": 1
+        },
+        "end": {
+          "line": 63,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "LabelledStatement",
+      "label": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 1
+          },
+          "end": {
+            "line": 64,
+            "column": 2
+          }
+        }
+      },
+      "body": {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "NumberLiteral",
+          "value": 3,
+          "loc": {
+            "start": {
+              "line": 64,
+              "column": 4
+            },
+            "end": {
+              "line": 64,
+              "column": 5
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 4
+          },
+          "end": {
+            "line": 64,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 64,
+          "column": 1
+        },
+        "end": {
+          "line": 64,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 65,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-labelled-statement.js b/es2panda/test/parser/js/test-labelled-statement.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b6251a1ff80580fd84515049895a54b4f03ccf0
--- /dev/null
+++ b/es2panda/test/parser/js/test-labelled-statement.js
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a: b;
+
+b: if (0) {}
+
+c: if (0) {} else {}
+
+d: while (0) {};
+
+e: do {} while (0);
+
+f: switch(0) {}
+
+g: try {} catch(e) {} finally {}
+
+function a()
+{
+  b:
+  {
+    a:
+    while(true)
+    {
+      break a;
+    }
+  }
+}
+
+
+function b()
+{
+  b:
+  {
+    a:
+    c:
+    while(true)
+    {
+      break b;
+    }
+  }
+}
+
+a:
+b:
+c:
+d: 1;
+
+a: 1;
+a: 2;
+a: 3;
diff --git a/es2panda/test/parser/js/test-labelled-statement1-expected.txt b/es2panda/test/parser/js/test-labelled-statement1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afac9aaf2a29f6016e13fdccde18afc6a5f7fc93
--- /dev/null
+++ b/es2panda/test/parser/js/test-labelled-statement1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Label already declared [test-labelled-statement1.js:18:1]
diff --git a/es2panda/test/parser/js/test-labelled-statement1.js b/es2panda/test/parser/js/test-labelled-statement1.js
new file mode 100644
index 0000000000000000000000000000000000000000..be53d6c7abb6bd22ac005853f06ae0f44e2f079f
--- /dev/null
+++ b/es2panda/test/parser/js/test-labelled-statement1.js
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a:
+a: 2;
diff --git a/es2panda/test/parser/js/test-labelled-statement2-expected.txt b/es2panda/test/parser/js/test-labelled-statement2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eb7abbb77a5106a2f054fd989ee3d28c149d6a45
--- /dev/null
+++ b/es2panda/test/parser/js/test-labelled-statement2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Undefined label [test-labelled-statement2.js:20:9]
diff --git a/es2panda/test/parser/js/test-labelled-statement2.js b/es2panda/test/parser/js/test-labelled-statement2.js
new file mode 100644
index 0000000000000000000000000000000000000000..36c24a71c0cfe8501c04f2e7d5d0093eccc5bf3e
--- /dev/null
+++ b/es2panda/test/parser/js/test-labelled-statement2.js
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a:
+while(true)
+{
+  break b; 
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-let-redeclaration-expected.txt b/es2panda/test/parser/js/test-let-redeclaration-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7088983779e00e5604d77357fca92af02a02cc8c
--- /dev/null
+++ b/es2panda/test/parser/js/test-let-redeclaration-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Variable 'a' has already been declared. [test-let-redeclaration.js:19:5]
diff --git a/es2panda/test/parser/js/test-let-redeclaration.js b/es2panda/test/parser/js/test-let-redeclaration.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ecfe7242a20325357f1698f9e78afc2cc5919f1
--- /dev/null
+++ b/es2panda/test/parser/js/test-let-redeclaration.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let a;
+let b;
+let a;
diff --git a/es2panda/test/parser/js/test-logical-expression-expected.txt b/es2panda/test/parser/js/test-logical-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a785cd7888f9be67f03c976cef17b8646ad12e01
--- /dev/null
+++ b/es2panda/test/parser/js/test-logical-expression-expected.txt
@@ -0,0 +1,762 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 6
+            },
+            "end": {
+              "line": 17,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 6
+            },
+            "end": {
+              "line": 18,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 2
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 6
+              },
+              "end": {
+                "line": 19,
+                "column": 7
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 7
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 11
+            },
+            "end": {
+              "line": 19,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 6
+              },
+              "end": {
+                "line": 20,
+                "column": 7
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 11
+              },
+              "end": {
+                "line": 20,
+                "column": 12
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 6
+            },
+            "end": {
+              "line": 20,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "||",
+          "left": {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 1
+                },
+                "end": {
+                  "line": 21,
+                  "column": 2
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 6
+                },
+                "end": {
+                  "line": 21,
+                  "column": 7
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 1
+              },
+              "end": {
+                "line": 21,
+                "column": 7
+              }
+            }
+          },
+          "right": {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 11
+                },
+                "end": {
+                  "line": 21,
+                  "column": 12
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 16
+                },
+                "end": {
+                  "line": 21,
+                  "column": 17
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 11
+              },
+              "end": {
+                "line": 21,
+                "column": 17
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 17
+            }
+          }
+        },
+        "right": {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": {
+            "type": "Identifier",
+            "name": "d",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 21
+              },
+              "end": {
+                "line": 21,
+                "column": 22
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "e",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 26
+              },
+              "end": {
+                "line": 21,
+                "column": 27
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 21
+            },
+            "end": {
+              "line": 21,
+              "column": 27
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "||",
+          "left": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 1
+              },
+              "end": {
+                "line": 22,
+                "column": 2
+              }
+            }
+          },
+          "right": {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": {
+              "type": "LogicalExpression",
+              "operator": "&&",
+              "left": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 7
+                  }
+                }
+              },
+              "right": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 12
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 6
+                },
+                "end": {
+                  "line": 22,
+                  "column": 12
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 16
+                },
+                "end": {
+                  "line": 22,
+                  "column": 17
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 6
+              },
+              "end": {
+                "line": 22,
+                "column": 17
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 17
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 21
+            },
+            "end": {
+              "line": 22,
+              "column": 22
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": {
+              "type": "LogicalExpression",
+              "operator": "&&",
+              "left": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 2
+                  }
+                }
+              },
+              "right": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 7
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 1
+                },
+                "end": {
+                  "line": 23,
+                  "column": 7
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "e",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 11
+                },
+                "end": {
+                  "line": 23,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 1
+              },
+              "end": {
+                "line": 23,
+                "column": 12
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 4
+              },
+              "end": {
+                "line": 24,
+                "column": 5
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "f",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 9
+            },
+            "end": {
+              "line": 24,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 25,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-logical-expression.js b/es2panda/test/parser/js/test-logical-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb7cf4a7b7b1f9d796c3e22c4ecdd85ee8411a62
--- /dev/null
+++ b/es2panda/test/parser/js/test-logical-expression.js
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a || b
+a && b;
+a && b || c
+a || b && c
+a && b || c && b || d && e
+a || b && c && d || e;
+b && a && e
+&& c || f;
diff --git a/es2panda/test/parser/js/test-member-expression-1-expected.txt b/es2panda/test/parser/js/test-member-expression-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6f3f9c24ff29cfa25b281367cc3d6867553ec6b2
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Expected an identifier [test-member-expression-1.js:17:3]
diff --git a/es2panda/test/parser/js/test-member-expression-1.js b/es2panda/test/parser/js/test-member-expression-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..b03388633bec8f9631a66d22a0fc09f47c914479
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a.(b)
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-member-expression-2-expected.txt b/es2panda/test/parser/js/test-member-expression-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..13f36a58dd67036b4ebd473790446676df9823a6
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-member-expression-2.js:17:4]
diff --git a/es2panda/test/parser/js/test-member-expression-2.js b/es2panda/test/parser/js/test-member-expression-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..3020012c1b1a93c0dbf1543302877863b5b97705
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression-2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a[b
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-member-expression-3-expected.txt b/es2panda/test/parser/js/test-member-expression-3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ab919b8c4b341ff9b09b6de227b1b0330e59da49
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression-3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-member-expression-3.js:17:9]
diff --git a/es2panda/test/parser/js/test-member-expression-3.js b/es2panda/test/parser/js/test-member-expression-3.js
new file mode 100644
index 0000000000000000000000000000000000000000..84a7a5e829c97e9ea8cab28b9fce997038335a72
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression-3.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+"sfs".b[]
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-member-expression-expected.txt b/es2panda/test/parser/js/test-member-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0ba8d05f25e85d2ee97c4fc25c4b0343c40efc71
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression-expected.txt
@@ -0,0 +1,776 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 2
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 3
+            },
+            "end": {
+              "line": 17,
+              "column": 4
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 2
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 3
+            },
+            "end": {
+              "line": 18,
+              "column": 4
+            }
+          }
+        },
+        "computed": true,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 5
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 5
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 1
+                },
+                "end": {
+                  "line": 19,
+                  "column": 2
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 3
+                },
+                "end": {
+                  "line": 19,
+                  "column": 4
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 4
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 5
+              },
+              "end": {
+                "line": 19,
+                "column": 6
+              }
+            }
+          },
+          "computed": false,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 6
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 8
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 1
+              },
+              "end": {
+                "line": 20,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 3
+              },
+              "end": {
+                "line": 20,
+                "column": 4
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 5
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 6
+            },
+            "end": {
+              "line": 20,
+              "column": 7
+            }
+          }
+        },
+        "computed": true,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 1
+              },
+              "end": {
+                "line": 21,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 3
+                },
+                "end": {
+                  "line": 21,
+                  "column": 4
+                }
+              }
+            },
+            "right": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 9
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 11
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 8
+                },
+                "end": {
+                  "line": 21,
+                  "column": 11
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 3
+              },
+              "end": {
+                "line": 21,
+                "column": 11
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 12
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 13
+              },
+              "end": {
+                "line": 21,
+                "column": 14
+              }
+            }
+          }
+        ],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 1
+                },
+                "end": {
+                  "line": 22,
+                  "column": 2
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 3
+                },
+                "end": {
+                  "line": 22,
+                  "column": 4
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 1
+              },
+              "end": {
+                "line": 22,
+                "column": 4
+              }
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 5
+              },
+              "end": {
+                "line": 22,
+                "column": 6
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 7
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 8
+            },
+            "end": {
+              "line": 22,
+              "column": 9
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 2
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 3
+            },
+            "end": {
+              "line": 23,
+              "column": 6
+            }
+          }
+        },
+        "computed": true,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 1
+              },
+              "end": {
+                "line": 24,
+                "column": 2
+              }
+            }
+          },
+          "property": {
+            "type": "LogicalExpression",
+            "operator": "||",
+            "left": {
+              "type": "StringLiteral",
+              "value": "dsfd",
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 3
+                },
+                "end": {
+                  "line": 24,
+                  "column": 9
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 13
+                },
+                "end": {
+                  "line": 24,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 3
+              },
+              "end": {
+                "line": 24,
+                "column": 14
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 15
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 16
+            },
+            "end": {
+              "line": 24,
+              "column": 17
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 25,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-member-expression.js b/es2panda/test/parser/js/test-member-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..e50a535488f43e8dc772ea6e3c303ec591a607b9
--- /dev/null
+++ b/es2panda/test/parser/js/test-member-expression.js
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a.b
+a[b]
+a.b.c.d
+a[b][c]
+a[b && c.d](2)
+a.b[c].d
+a[(b)]
+a["dsfd" || c].b
diff --git a/es2panda/test/parser/js/test-missing-catch-argument-expected.txt b/es2panda/test/parser/js/test-missing-catch-argument-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7ba5ef6b7dc72f3671ed7af40aa516fe2074390d
--- /dev/null
+++ b/es2panda/test/parser/js/test-missing-catch-argument-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token in catch parameter [test-missing-catch-argument.js:21:7]
diff --git a/es2panda/test/parser/js/test-missing-catch-argument.js b/es2panda/test/parser/js/test-missing-catch-argument.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc49d97e6cce78b014eab2afaf9e40aad684c357
--- /dev/null
+++ b/es2panda/test/parser/js/test-missing-catch-argument.js
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+try
+{
+
+}
+catch()
+{
+
+}
+finally
+{
+
+}
diff --git a/es2panda/test/parser/js/test-multi-line-string-expected.txt b/es2panda/test/parser/js/test-multi-line-string-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..728c881be80989accb24e09656d312cdfde07bed
--- /dev/null
+++ b/es2panda/test/parser/js/test-multi-line-string-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Newline is not allowed in strings [test-multi-line-string.js:16:610]
diff --git a/es2panda/test/parser/js/test-multi-line-string.js b/es2panda/test/parser/js/test-multi-line-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..080eabdb2def7bf61aeeafe96f88f530ca820a72
--- /dev/null
+++ b/es2panda/test/parser/js/test-multi-line-string.js
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+"foo
+
+
+"
diff --git a/es2panda/test/parser/js/test-multiple-update-expression-expected.txt b/es2panda/test/parser/js/test-multiple-update-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e23763abd0d964883fb3c234e055b797e453e4f
--- /dev/null
+++ b/es2panda/test/parser/js/test-multiple-update-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-multiple-update-expression.js:17:5]
diff --git a/es2panda/test/parser/js/test-multiple-update-expression.js b/es2panda/test/parser/js/test-multiple-update-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed0d2569ccd840f65c28fec2ceda7184f47cd99f
--- /dev/null
+++ b/es2panda/test/parser/js/test-multiple-update-expression.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a++ ++b;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-new-expression-expected.txt b/es2panda/test/parser/js/test-new-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8263cdc897873907cd6b6ecddc1f617b4953a51b
--- /dev/null
+++ b/es2panda/test/parser/js/test-new-expression-expected.txt
@@ -0,0 +1,443 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NewExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NewExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 5
+            },
+            "end": {
+              "line": 18,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 7
+              },
+              "end": {
+                "line": 18,
+                "column": 8
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 9
+              },
+              "end": {
+                "line": 18,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NewExpression",
+        "callee": {
+          "type": "NewExpression",
+          "callee": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "MemberExpression",
+              "object": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 14
+                  }
+                }
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 16
+                  }
+                }
+              },
+              "computed": false,
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 13
+                },
+                "end": {
+                  "line": 19,
+                  "column": 16
+                }
+              }
+            },
+            "arguments": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 9
+              },
+              "end": {
+                "line": 19,
+                "column": 16
+              }
+            }
+          },
+          "arguments": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 5
+            },
+            "end": {
+              "line": 19,
+              "column": 16
+            }
+          }
+        },
+        "arguments": [],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NewExpression",
+        "callee": {
+          "type": "NewExpression",
+          "callee": {
+            "type": "ArrayExpression",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 9
+              },
+              "end": {
+                "line": 20,
+                "column": 12
+              }
+            }
+          },
+          "arguments": [
+            {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 13
+                },
+                "end": {
+                  "line": 20,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 5
+            },
+            "end": {
+              "line": 20,
+              "column": 15
+            }
+          }
+        },
+        "arguments": [],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NewExpression",
+        "callee": {
+          "type": "NewExpression",
+          "callee": {
+            "type": "NewExpression",
+            "callee": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 13
+                },
+                "end": {
+                  "line": 21,
+                  "column": 14
+                }
+              }
+            },
+            "arguments": [
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 16
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 9
+              },
+              "end": {
+                "line": 21,
+                "column": 17
+              }
+            }
+          },
+          "arguments": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 17
+            }
+          }
+        },
+        "arguments": [],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NewExpression",
+        "callee": {
+          "type": "StringLiteral",
+          "value": "foo",
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 5
+            },
+            "end": {
+              "line": 22,
+              "column": 10
+            }
+          }
+        },
+        "arguments": [],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 13
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 23,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-new-expression.js b/es2panda/test/parser/js/test-new-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..0879a6065561637f73aaec98f23bc5e8d12328c9
--- /dev/null
+++ b/es2panda/test/parser/js/test-new-expression.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+new a;
+new a(b,c);
+new new new a.b;
+new new [a](5)();
+new new new a(b);
+new "foo"();
diff --git a/es2panda/test/parser/js/test-nullish-coalescing-expected.txt b/es2panda/test/parser/js/test-nullish-coalescing-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1834ddc65f3ca099a62fc2e4a4deb2f1a9659221
--- /dev/null
+++ b/es2panda/test/parser/js/test-nullish-coalescing-expected.txt
@@ -0,0 +1,1131 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "==",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "??",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 2
+              },
+              "end": {
+                "line": 17,
+                "column": 3
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 7
+              },
+              "end": {
+                "line": 17,
+                "column": 8
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 1,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 13
+            },
+            "end": {
+              "line": 17,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "==",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "??",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 0,
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 2
+              },
+              "end": {
+                "line": 18,
+                "column": 3
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 7
+              },
+              "end": {
+                "line": 18,
+                "column": 8
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 9
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 0,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 13
+            },
+            "end": {
+              "line": 18,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "??",
+        "left": {
+          "type": "NullLiteral",
+          "value": null,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 9
+              },
+              "end": {
+                "line": 19,
+                "column": 10
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 14
+              },
+              "end": {
+                "line": 19,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 9
+            },
+            "end": {
+              "line": 19,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "??",
+        "left": {
+          "type": "NullLiteral",
+          "value": null,
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "Identifier",
+            "name": "undefined",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 9
+              },
+              "end": {
+                "line": 20,
+                "column": 18
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "undefined",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 22
+              },
+              "end": {
+                "line": 20,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 9
+            },
+            "end": {
+              "line": 20,
+              "column": 31
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 31
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "??",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "??",
+          "left": {
+            "type": "NullLiteral",
+            "value": null,
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 1
+              },
+              "end": {
+                "line": 21,
+                "column": 5
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "undefined",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 9
+              },
+              "end": {
+                "line": 21,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 18
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 22
+              },
+              "end": {
+                "line": 21,
+                "column": 23
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 27
+              },
+              "end": {
+                "line": 21,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 22
+            },
+            "end": {
+              "line": 21,
+              "column": 28
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 28
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "??",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "??",
+          "left": {
+            "type": "LogicalExpression",
+            "operator": "??",
+            "left": {
+              "type": "NullLiteral",
+              "value": null,
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 1
+                },
+                "end": {
+                  "line": 22,
+                  "column": 5
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "undefined",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 9
+                },
+                "end": {
+                  "line": 22,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 1
+              },
+              "end": {
+                "line": 22,
+                "column": 18
+              }
+            }
+          },
+          "right": {
+            "type": "NullLiteral",
+            "value": null,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 22
+              },
+              "end": {
+                "line": 22,
+                "column": 26
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 1
+            },
+            "end": {
+              "line": 22,
+              "column": 26
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 10,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 30
+              },
+              "end": {
+                "line": 22,
+                "column": 32
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 10,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 36
+              },
+              "end": {
+                "line": 22,
+                "column": 38
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 30
+            },
+            "end": {
+              "line": 22,
+              "column": 38
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 38
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 39
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "??",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "??",
+          "left": {
+            "type": "NullLiteral",
+            "value": null,
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 1
+              },
+              "end": {
+                "line": 23,
+                "column": 5
+              }
+            }
+          },
+          "right": {
+            "type": "LogicalExpression",
+            "operator": "||",
+            "left": {
+              "type": "Identifier",
+              "name": "undefined",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 10
+                },
+                "end": {
+                  "line": 23,
+                  "column": 19
+                }
+              }
+            },
+            "right": {
+              "type": "NullLiteral",
+              "value": null,
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 23
+                },
+                "end": {
+                  "line": 23,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 9
+              },
+              "end": {
+                "line": 23,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 28
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 10,
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 32
+              },
+              "end": {
+                "line": 23,
+                "column": 34
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 10,
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 38
+              },
+              "end": {
+                "line": 23,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 32
+            },
+            "end": {
+              "line": 23,
+              "column": 40
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 40
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 41
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "??",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "??",
+          "left": {
+            "type": "NullLiteral",
+            "value": null,
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 1
+              },
+              "end": {
+                "line": 24,
+                "column": 5
+              }
+            }
+          },
+          "right": {
+            "type": "LogicalExpression",
+            "operator": "&&",
+            "left": {
+              "type": "Identifier",
+              "name": "undefined",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 10
+                },
+                "end": {
+                  "line": 24,
+                  "column": 19
+                }
+              }
+            },
+            "right": {
+              "type": "NullLiteral",
+              "value": null,
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 23
+                },
+                "end": {
+                  "line": 24,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 9
+              },
+              "end": {
+                "line": 24,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 28
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 10,
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 32
+              },
+              "end": {
+                "line": 24,
+                "column": 34
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 10,
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 38
+              },
+              "end": {
+                "line": 24,
+                "column": 40
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 32
+            },
+            "end": {
+              "line": 24,
+              "column": 40
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 40
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 41
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": {
+          "type": "LogicalExpression",
+          "operator": "??",
+          "left": {
+            "type": "NullLiteral",
+            "value": null,
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 2
+              },
+              "end": {
+                "line": 25,
+                "column": 6
+              }
+            }
+          },
+          "right": {
+            "type": "BooleanLiteral",
+            "value": true,
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 10
+              },
+              "end": {
+                "line": 25,
+                "column": 14
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 15
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "==",
+          "left": {
+            "type": "LogicalExpression",
+            "operator": "??",
+            "left": {
+              "type": "BooleanLiteral",
+              "value": true,
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 20
+                },
+                "end": {
+                  "line": 25,
+                  "column": 24
+                }
+              }
+            },
+            "right": {
+              "type": "NullLiteral",
+              "value": null,
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 28
+                },
+                "end": {
+                  "line": 25,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 19
+              },
+              "end": {
+                "line": 25,
+                "column": 33
+              }
+            }
+          },
+          "right": {
+            "type": "BooleanLiteral",
+            "value": true,
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 37
+              },
+              "end": {
+                "line": 25,
+                "column": 41
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 19
+            },
+            "end": {
+              "line": 25,
+              "column": 41
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 41
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 41
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "??",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": "+",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 1
+              },
+              "end": {
+                "line": 26,
+                "column": 2
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 3,
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 26,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 1
+            },
+            "end": {
+              "line": 26,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "*",
+          "left": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 10
+              },
+              "end": {
+                "line": 26,
+                "column": 11
+              }
+            }
+          },
+          "right": {
+            "type": "NumberLiteral",
+            "value": 8,
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 14
+              },
+              "end": {
+                "line": 26,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 10
+            },
+            "end": {
+              "line": 26,
+              "column": 15
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 26,
+      "column": 16
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-nullish-coalescing.js b/es2panda/test/parser/js/test-nullish-coalescing.js
new file mode 100644
index 0000000000000000000000000000000000000000..e71921beb50ecc43280927dfe59536de0ccb4a36
--- /dev/null
+++ b/es2panda/test/parser/js/test-nullish-coalescing.js
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(1 ?? 2) == 1;
+(0 ?? 2) == 0;
+null ?? 2 == 2;
+null ?? undefined == undefined;
+null ?? undefined ?? 2 == 2;
+null ?? undefined ?? null ?? 10 == 10;
+null ?? (undefined || null) ?? 10 == 10;
+null ?? (undefined && null) ?? 10 == 10;
+(null ?? true) && (true ?? null) == true
+5 + 3 ?? 5 * 8;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-nullish-coalescing1-expected.txt b/es2panda/test/parser/js/test-nullish-coalescing1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e05ec5c230636c7a4388d8254e3458bd5f69b9f
--- /dev/null
+++ b/es2panda/test/parser/js/test-nullish-coalescing1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Nullish coalescing operator ?? requires parens when mixing with logical operators. [test-nullish-coalescing1.js:17:22]
diff --git a/es2panda/test/parser/js/test-nullish-coalescing1.js b/es2panda/test/parser/js/test-nullish-coalescing1.js
new file mode 100644
index 0000000000000000000000000000000000000000..a52d728219bca6ba6bd05765f2ca4b42c9faaecc
--- /dev/null
+++ b/es2panda/test/parser/js/test-nullish-coalescing1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(null ?? null || null)
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-nullish-coalescing2-expected.txt b/es2panda/test/parser/js/test-nullish-coalescing2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..048dd98cdb5f7cc5f7a6635814a4bce5acea774d
--- /dev/null
+++ b/es2panda/test/parser/js/test-nullish-coalescing2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Nullish coalescing operator ?? requires parens when mixing with logical operators. [test-nullish-coalescing2.js:17:22]
diff --git a/es2panda/test/parser/js/test-nullish-coalescing2.js b/es2panda/test/parser/js/test-nullish-coalescing2.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fdc15c8184dfeeb2c5f25b8ea9980da6a74e115
--- /dev/null
+++ b/es2panda/test/parser/js/test-nullish-coalescing2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(null && null ?? null)
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-numeric-separator-expected.txt b/es2panda/test/parser/js/test-numeric-separator-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..77574b8f60b79178a3bbe6fe03279b9c2a1219cd
--- /dev/null
+++ b/es2panda/test/parser/js/test-numeric-separator-expected.txt
@@ -0,0 +1,177 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NumberLiteral",
+        "value": 43793,
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NumberLiteral",
+        "value": 33,
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NumberLiteral",
+        "value": 36,
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 6
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NumberLiteral",
+        "value": "Infinity",
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NumberLiteral",
+        "value": 12313.1,
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "NumberLiteral",
+        "value": 1.234e+57,
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 22,
+      "column": 12
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-numeric-separator.js b/es2panda/test/parser/js/test-numeric-separator.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b8887009464b76b53234a228edd03a0b32a7a27
--- /dev/null
+++ b/es2panda/test/parser/js/test-numeric-separator.js
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+0xA_B_1_1
+0b1_0000_1
+0o4_4
+123_1232_1_3e+11_11
+123_1_3.12_12
+1_2.3_4e5_6
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-numeric-separator1-expected.txt b/es2panda/test/parser/js/test-numeric-separator1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..798c9676105f3981342e0618f55392bdd99768da
--- /dev/null
+++ b/es2panda/test/parser/js/test-numeric-separator1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Invalid numeric separator [test-numeric-separator1.js:16:608]
diff --git a/es2panda/test/parser/js/test-numeric-separator1.js b/es2panda/test/parser/js/test-numeric-separator1.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0f4217f11574b92fcc128848407f94a52f40727
--- /dev/null
+++ b/es2panda/test/parser/js/test-numeric-separator1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+1__1
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-numeric-separator2-expected.txt b/es2panda/test/parser/js/test-numeric-separator2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cfbce5e572266dfa7716a17c5d5a35a145026a65
--- /dev/null
+++ b/es2panda/test/parser/js/test-numeric-separator2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Numeric separators are not allowed at the end of numeric literals [test-numeric-separator2.js:16:611]
diff --git a/es2panda/test/parser/js/test-numeric-separator2.js b/es2panda/test/parser/js/test-numeric-separator2.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c34f12605c2cf53a7f065b9acd50515968daeb5
--- /dev/null
+++ b/es2panda/test/parser/js/test-numeric-separator2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+1111_
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-object-expression-expected.txt b/es2panda/test/parser/js/test-object-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0b4d61631a1fe145d38dfa96fe8bbcb1b44be3cc
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression-expected.txt
@@ -0,0 +1,959 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "get",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 18,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "get",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 18,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 6
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 6
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": true,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "get",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 19,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 19,
+                          "column": 10
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 19,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 19,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 10
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "set",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": true,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 5
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "foo",
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 12
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 12
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "StringLiteral",
+                  "value": "foo",
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 12
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 16
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 16
+                    }
+                  }
+                },
+                "kind": "get",
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 16
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": true,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 9
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 14
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 14
+                    }
+                  }
+                },
+                "kind": "get",
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "SpreadElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 7
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": true,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 42,
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 5
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 7
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 9
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 9
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 26,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 10
+                          }
+                        }
+                      }
+                    ],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 26,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 26,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "set",
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 13
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "true",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 7
+                    }
+                  }
+                },
+                "value": {
+                  "type": "NumberLiteral",
+                  "value": 5,
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 9
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 9
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "implements",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 13
+                    }
+                  }
+                },
+                "value": {
+                  "type": "StringLiteral",
+                  "value": "foo",
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 19
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 19
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 8
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 10
+                          }
+                        }
+                      }
+                    ],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ExpressionStatement",
+                          "expression": {
+                            "type": "MemberExpression",
+                            "object": {
+                              "type": "Super",
+                              "loc": {
+                                "start": {
+                                  "line": 29,
+                                  "column": 12
+                                },
+                                "end": {
+                                  "line": 29,
+                                  "column": 17
+                                }
+                              }
+                            },
+                            "property": {
+                              "type": "Identifier",
+                              "name": "a",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 29,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 29,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "computed": false,
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 29,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 29,
+                              "column": 19
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 20
+                    }
+                  }
+                },
+                "kind": "set",
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 20
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": true,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "f",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 10
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": true,
+                    "expression": false,
+                    "params": [],
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 14
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 14
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 14
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 9
+              },
+              "end": {
+                "line": 31,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 31,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 32,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-object-expression.js b/es2panda/test/parser/js/test-object-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..1557519d545a80212b38827e6f97b46396b9f97d
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression.js
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {
+  get,
+  get(){},
+  set:5,
+  [a]:"foo",
+  get "foo"(){},
+  get [b](){},
+  ...a,
+  42(){},
+  set a(a){},
+  true:5,
+  implements:"foo",
+  set a(b){super.a},
+  async f(){}
+}
diff --git a/es2panda/test/parser/js/test-object-expression1-expected.txt b/es2panda/test/parser/js/test-object-expression1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..23d2e9051cfe685942c7a8a15e78a5e80703e3e4
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Setter must have exactly one formal parameter [test-object-expression1.js:19:1]
diff --git a/es2panda/test/parser/js/test-object-expression1.js b/es2panda/test/parser/js/test-object-expression1.js
new file mode 100644
index 0000000000000000000000000000000000000000..8eb099fe6646fdcc18572a374fb3c0f83fc78099
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression1.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = {
+  set a(b,c){}
+}
diff --git a/es2panda/test/parser/js/test-object-expression2-expected.txt b/es2panda/test/parser/js/test-object-expression2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e8ab2f0dbd4b97681e784f2923ef7d0d6593c64c
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected '(' [test-object-expression2.js:18:8]
diff --git a/es2panda/test/parser/js/test-object-expression2.js b/es2panda/test/parser/js/test-object-expression2.js
new file mode 100644
index 0000000000000000000000000000000000000000..00ee1e7328e6900d0cbfd5b2d4054cb9d3c328ed
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression2.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = {
+  get a[b](){},
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-object-expression3-expected.txt b/es2panda/test/parser/js/test-object-expression3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e6b19136d0bf50c18c617057eb3c2be84bd4b51b
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected ':' [test-object-expression3.js:18:4]
diff --git a/es2panda/test/parser/js/test-object-expression3.js b/es2panda/test/parser/js/test-object-expression3.js
new file mode 100644
index 0000000000000000000000000000000000000000..e255053a2e0f7ff52ac12cceee5a91f7a8ff724d
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression3.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = {
+  a"foo",
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-object-expression4-expected.txt b/es2panda/test/parser/js/test-object-expression4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..17621c70441582a7aede15f1edfb9187943c1e4d
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Expected an identifier [test-object-expression4.js:18:3]
diff --git a/es2panda/test/parser/js/test-object-expression4.js b/es2panda/test/parser/js/test-object-expression4.js
new file mode 100644
index 0000000000000000000000000000000000000000..606df39a0cde724880737f80f15f706b07a6089c
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression4.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a = {
+  if,
+}
diff --git a/es2panda/test/parser/js/test-object-expression5-expected.txt b/es2panda/test/parser/js/test-object-expression5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d295e28d4462e95f50138f1cd7364f40a0a68f7a
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected super keyword [test-object-expression5.js:18:12]
diff --git a/es2panda/test/parser/js/test-object-expression5.js b/es2panda/test/parser/js/test-object-expression5.js
new file mode 100644
index 0000000000000000000000000000000000000000..b68e5b534e651d2e0bae7943685fd297fdcc3a5d
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-expression5.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {
+  a(){super()}
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-object-proto-expected.txt b/es2panda/test/parser/js/test-object-proto-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9c18b68a523d7d32f3da47c5196e7cf094276e22
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-proto-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Duplicate __proto__ fields are not allowed in object literals [test-object-proto.js:25:3]
diff --git a/es2panda/test/parser/js/test-object-proto.js b/es2panda/test/parser/js/test-object-proto.js
new file mode 100644
index 0000000000000000000000000000000000000000..4be66d7c38beb55e99394aa3de99becb64acfbad
--- /dev/null
+++ b/es2panda/test/parser/js/test-object-proto.js
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {
+  get __proto__(){}, 
+  [__proto__]: 5,
+  __proto__: 7,
+  __proto__,
+  __proto__(){},
+  __proto__(){},
+  *__proto__(){},
+  __proto__: 8,
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-one-default-export-allowed-expected.txt b/es2panda/test/parser/js/test-one-default-export-allowed-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cd7e9d856c4c45e7ecfb0d0e904feace28531155
--- /dev/null
+++ b/es2panda/test/parser/js/test-one-default-export-allowed-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'import' and 'export' may appear only with 'sourceType: module' [test-one-default-export-allowed.js:20:1]
diff --git a/es2panda/test/parser/js/test-one-default-export-allowed.js b/es2panda/test/parser/js/test-one-default-export-allowed.js
new file mode 100644
index 0000000000000000000000000000000000000000..c206e2209f39ce7424e5c41f858d2eebbfed24e8
--- /dev/null
+++ b/es2panda/test/parser/js/test-one-default-export-allowed.js
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*---
+flags: [module]
+---*/
+
+export default a = 1;
+export default b = 2;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-optional-chain-expected.txt b/es2panda/test/parser/js/test-optional-chain-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c28a2f1282540c4147017b3ad6e5af928324d59
--- /dev/null
+++ b/es2panda/test/parser/js/test-optional-chain-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Tagged Template Literals are not allowed in optionalChain [test-optional-chain.js:17:10]
diff --git a/es2panda/test/parser/js/test-optional-chain.js b/es2panda/test/parser/js/test-optional-chain.js
new file mode 100644
index 0000000000000000000000000000000000000000..5276fa55be00470285c68cf603f4f6fe52bf4cfb
--- /dev/null
+++ b/es2panda/test/parser/js/test-optional-chain.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a?.a?.a?.``
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-patterns-expected.txt b/es2panda/test/parser/js/test-patterns-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bf6b740a4b2753c61d62ca1719bd602cff230a89
--- /dev/null
+++ b/es2panda/test/parser/js/test-patterns-expected.txt
@@ -0,0 +1,990 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 10
+            },
+            "end": {
+              "line": 17,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 17
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 21
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 21
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 24
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 24
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 24
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 27
+                    }
+                  }
+                },
+                "value": {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "LogicalExpression",
+                    "operator": "||",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 32
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 32
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 15
+              },
+              "end": {
+                "line": 17,
+                "column": 33
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 34
+            },
+            "end": {
+              "line": 17,
+              "column": 36
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 36
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "bar",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 10
+            },
+            "end": {
+              "line": 18,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 15
+              },
+              "end": {
+                "line": 18,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 17
+              },
+              "end": {
+                "line": 18,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 19
+                },
+                "end": {
+                  "line": 18,
+                  "column": 20
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 21
+                },
+                "end": {
+                  "line": 18,
+                  "column": 22
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 19
+              },
+              "end": {
+                "line": 18,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 23
+            },
+            "end": {
+              "line": 18,
+              "column": 25
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 25
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foobar",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 10
+            },
+            "end": {
+              "line": 19,
+              "column": 16
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 4
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 5
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 3
+                },
+                "end": {
+                  "line": 20,
+                  "column": 6
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 2,
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 7
+                },
+                "end": {
+                  "line": 20,
+                  "column": 8
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 3
+              },
+              "end": {
+                "line": 20,
+                "column": 8
+              }
+            }
+          },
+          {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 4
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 5
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 3
+              },
+              "end": {
+                "line": 21,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 3
+              },
+              "end": {
+                "line": 22,
+                "column": 4
+              }
+            }
+          },
+          {
+            "type": "ObjectPattern",
+            "properties": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 3
+              },
+              "end": {
+                "line": 23,
+                "column": 5
+              }
+            }
+          },
+          {
+            "type": "ArrayPattern",
+            "elements": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 3
+              },
+              "end": {
+                "line": 24,
+                "column": 5
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 2
+            },
+            "end": {
+              "line": 25,
+              "column": 4
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "test1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 10
+            },
+            "end": {
+              "line": 26,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "rest",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 19
+                },
+                "end": {
+                  "line": 26,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 16
+              },
+              "end": {
+                "line": 26,
+                "column": 23
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 24
+            },
+            "end": {
+              "line": 26,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 1
+          },
+          "end": {
+            "line": 26,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "test2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 10
+            },
+            "end": {
+              "line": 27,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "RestElement",
+                  "argument": {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "RestElement",
+                        "argument": {
+                          "type": "Identifier",
+                          "name": "rest",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 31
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 31
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 27,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 27,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 19
+                },
+                "end": {
+                  "line": 27,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 16
+              },
+              "end": {
+                "line": 27,
+                "column": 33
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 34
+            },
+            "end": {
+              "line": 27,
+              "column": 36
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 36
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "test3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 10
+            },
+            "end": {
+              "line": 28,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 18
+                  }
+                }
+              },
+              {
+                "type": "ArrayPattern",
+                "elements": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 28,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 28,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 22
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 16
+              },
+              "end": {
+                "line": 28,
+                "column": 23
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 24
+            },
+            "end": {
+              "line": 28,
+              "column": 26
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 1
+          },
+          "end": {
+            "line": 28,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 26
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 28,
+      "column": 26
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-patterns.js b/es2panda/test/parser/js/test-patterns.js
new file mode 100644
index 0000000000000000000000000000000000000000..28277e28a96f3a53995589faa64cca6f1b4bb4e8
--- /dev/null
+++ b/es2panda/test/parser/js/test-patterns.js
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo ({a = b, c, d=a||b}){}
+function bar (a,b,c=1){}
+function foobar(
+  [a]=2, 
+  [b],
+  c,
+  {},
+  []
+){}
+function test1(...rest){}
+function test2(...[...[...rest]]){}
+function test3([b,[a]]){}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-sequence-expression-expected.txt b/es2panda/test/parser/js/test-sequence-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d50c022d72cd9a4e428ebdaff7fcc366bcbd756
--- /dev/null
+++ b/es2panda/test/parser/js/test-sequence-expression-expected.txt
@@ -0,0 +1,421 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 1
+              },
+              "end": {
+                "line": 17,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 4
+              },
+              "end": {
+                "line": 17,
+                "column": 5
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 7
+              },
+              "end": {
+                "line": 17,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 1
+                },
+                "end": {
+                  "line": 19,
+                  "column": 2
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 5
+                },
+                "end": {
+                  "line": 19,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 3
+              },
+              "end": {
+                "line": 20,
+                "column": 4
+              }
+            }
+          },
+          {
+            "type": "NumberLiteral",
+            "value": 123,
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "SequenceExpression",
+        "expressions": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 1
+              },
+              "end": {
+                "line": 23,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "BinaryExpression",
+            "operator": "+",
+            "left": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 5
+                },
+                "end": {
+                  "line": 23,
+                  "column": 6
+                }
+              }
+            },
+            "right": {
+              "type": "SequenceExpression",
+              "expressions": [
+                {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 11
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 9
+                },
+                "end": {
+                  "line": 23,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 4
+              },
+              "end": {
+                "line": 23,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "e",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 18
+              },
+              "end": {
+                "line": 23,
+                "column": 19
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "SequenceExpression",
+            "expressions": [
+              {
+                "type": "NumberLiteral",
+                "value": 1,
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 2,
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 14
+                  }
+                }
+              },
+              {
+                "type": "NumberLiteral",
+                "value": 3,
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 17
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 9
+              },
+              "end": {
+                "line": 25,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 18
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 26,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-sequence-expression.js b/es2panda/test/parser/js/test-sequence-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..ff7c0aa3fc88861b56432871d0b98e61616725e8
--- /dev/null
+++ b/es2panda/test/parser/js/test-sequence-expression.js
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+a, b, c;
+
+a = 1,
+  b,
+    123
+
+a, (b + (c, d)), e
+
+var a = (1, 2, 3)
diff --git a/es2panda/test/parser/js/test-string-literal-expected.txt b/es2panda/test/parser/js/test-string-literal-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..89661371f9a7e90883c6d455481059fb57bd01bc
--- /dev/null
+++ b/es2panda/test/parser/js/test-string-literal-expected.txt
@@ -0,0 +1,150 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "StringLiteral",
+        "value": "string",
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "StringLiteral",
+        "value": "string",
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 3
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 3
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 22,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-string-literal.js b/es2panda/test/parser/js/test-string-literal.js
new file mode 100644
index 0000000000000000000000000000000000000000..a55fccfef5750eb1538e4c2fb3736381c18a0de7
--- /dev/null
+++ b/es2panda/test/parser/js/test-string-literal.js
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+'\u0012'
+"string"
+'string'
+""
+''
diff --git a/es2panda/test/parser/js/test-super-expression-expected.txt b/es2panda/test/parser/js/test-super-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e6352a29602019f4ebb32433c0d5e908104e978f
--- /dev/null
+++ b/es2panda/test/parser/js/test-super-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected super keyword [test-super-expression.js:17:6]
diff --git a/es2panda/test/parser/js/test-super-expression.js b/es2panda/test/parser/js/test-super-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..676ff27cded464aaf1a21c5e61e8ecddb8747099
--- /dev/null
+++ b/es2panda/test/parser/js/test-super-expression.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+super;
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-switch-1-expected.txt b/es2panda/test/parser/js/test-switch-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..91d08c1c44f3274a0d454cfebb94edf0389805aa
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected '(' [test-switch-1.js:18:1]
diff --git a/es2panda/test/parser/js/test-switch-1.js b/es2panda/test/parser/js/test-switch-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..2717f2abfa1a9c7c5a26bc579094e64e69eeab24
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+switch
diff --git a/es2panda/test/parser/js/test-switch-2-expected.txt b/es2panda/test/parser/js/test-switch-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e4f755b7ac0fb26f02ddc2975d6fd5f5749dcee
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected '(' [test-switch-2.js:17:8]
diff --git a/es2panda/test/parser/js/test-switch-2.js b/es2panda/test/parser/js/test-switch-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..a272d3c93c9de354c769e727374673857c214c0b
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-2.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+switch {
+
+}
diff --git a/es2panda/test/parser/js/test-switch-3-expected.txt b/es2panda/test/parser/js/test-switch-3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c2df28a808d0f86b2b53cb287b4df92eff6e6fce
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-switch-3.js:17:9]
diff --git a/es2panda/test/parser/js/test-switch-3.js b/es2panda/test/parser/js/test-switch-3.js
new file mode 100644
index 0000000000000000000000000000000000000000..d7cab30b4083a42f714343e584557c5af6a1891f
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-3.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+switch () {
+
+}
diff --git a/es2panda/test/parser/js/test-switch-4-expected.txt b/es2panda/test/parser/js/test-switch-4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9af9b087ac2d9f26a5e69512303f0bbcbfdc6d8d
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected 'case' or 'default'. [test-switch-4.js:18:3]
diff --git a/es2panda/test/parser/js/test-switch-4.js b/es2panda/test/parser/js/test-switch-4.js
new file mode 100644
index 0000000000000000000000000000000000000000..c40a9e67a6f72a2ac45fdacf200b8398f400a285
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-4.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+switch (alma) {
+  function (){}
+}
diff --git a/es2panda/test/parser/js/test-switch-5-expected.txt b/es2panda/test/parser/js/test-switch-5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..987167aaa9ae030d664ceffbedc9615f737befe6
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Multiple default clauses. [test-switch-5.js:19:3]
diff --git a/es2panda/test/parser/js/test-switch-5.js b/es2panda/test/parser/js/test-switch-5.js
new file mode 100644
index 0000000000000000000000000000000000000000..4d09de2740bfd4f561bf38f1b362741d97335715
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-5.js
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+switch (alma) {
+  default:
+  default:
+}
diff --git a/es2panda/test/parser/js/test-switch-6-expected.txt b/es2panda/test/parser/js/test-switch-6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bd88f63bb6caa65b7316e310ab2398ae8e8e613f
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-switch-6.js:18:36]
diff --git a/es2panda/test/parser/js/test-switch-6.js b/es2panda/test/parser/js/test-switch-6.js
new file mode 100644
index 0000000000000000000000000000000000000000..eabe3ff86d409315ac5f74d88a9dac99d06f8b05
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-6.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+switch (a) {
+  case 1: AnimationPlaybackEvent() case 2:
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-switch-expected.txt b/es2panda/test/parser/js/test-switch-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..894e63f2744b9cbcb98445af23dac0c4c0c78a62
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch-expected.txt
@@ -0,0 +1,267 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "SwitchStatement",
+      "discriminant": {
+        "type": "Identifier",
+        "name": "key",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 9
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "cases": [
+        {
+          "type": "SwitchCase",
+          "test": {
+            "type": "Identifier",
+            "name": "value",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 10
+              },
+              "end": {
+                "line": 18,
+                "column": 15
+              }
+            }
+          },
+          "consequent": [
+            {
+              "type": "BreakStatement",
+              "label": null,
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 9
+                },
+                "end": {
+                  "line": 19,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 5
+            },
+            "end": {
+              "line": 19,
+              "column": 15
+            }
+          }
+        },
+        {
+          "type": "SwitchCase",
+          "test": null,
+          "consequent": [
+            {
+              "type": "BreakStatement",
+              "label": null,
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 9
+                },
+                "end": {
+                  "line": 22,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 22,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "SwitchStatement",
+      "discriminant": {
+        "type": "Identifier",
+        "name": "test",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 9
+          },
+          "end": {
+            "line": 25,
+            "column": 13
+          }
+        }
+      },
+      "cases": [],
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "SwitchStatement",
+      "discriminant": {
+        "type": "Identifier",
+        "name": "t",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 9
+          },
+          "end": {
+            "line": 27,
+            "column": 10
+          }
+        }
+      },
+      "cases": [
+        {
+          "type": "SwitchCase",
+          "test": null,
+          "consequent": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 5
+            },
+            "end": {
+              "line": 28,
+              "column": 13
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "SwitchStatement",
+      "discriminant": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 2
+          },
+          "end": {
+            "line": 32,
+            "column": 3
+          }
+        }
+      },
+      "cases": [
+        {
+          "type": "SwitchCase",
+          "test": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 1
+              },
+              "end": {
+                "line": 35,
+                "column": 2
+              }
+            }
+          },
+          "consequent": [],
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 1
+            },
+            "end": {
+              "line": 35,
+              "column": 3
+            }
+          }
+        },
+        {
+          "type": "SwitchCase",
+          "test": null,
+          "consequent": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 1
+            },
+            "end": {
+              "line": 37,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 38,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-switch.js b/es2panda/test/parser/js/test-switch.js
new file mode 100644
index 0000000000000000000000000000000000000000..a359d8b36ddd00f814fc425aea56f7cd7f388c73
--- /dev/null
+++ b/es2panda/test/parser/js/test-switch.js
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+switch (key) {
+    case value:
+        break;
+
+    default:
+        break;
+}
+
+switch (test) {}
+
+switch (t) {
+    default:
+}
+
+switch
+(a)
+{
+case
+a:
+default
+:
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-tagged-template-expression-expected.txt b/es2panda/test/parser/js/test-tagged-template-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3447b7222689ba79b80a8df58453a3079f69551
--- /dev/null
+++ b/es2panda/test/parser/js/test-tagged-template-expression-expected.txt
@@ -0,0 +1,1101 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "Identifier",
+          "name": "alma",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 5
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 6
+                },
+                "end": {
+                  "line": 17,
+                  "column": 6
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "Identifier",
+          "name": "fa",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 3
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [
+            {
+              "type": "UpdateExpression",
+              "operator": "++",
+              "prefix": false,
+              "argument": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 7
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 6
+                },
+                "end": {
+                  "line": 19,
+                  "column": 9
+                }
+              }
+            }
+          ],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 4
+                },
+                "end": {
+                  "line": 19,
+                  "column": 4
+                }
+              }
+            },
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 10
+                },
+                "end": {
+                  "line": 19,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 3
+            },
+            "end": {
+              "line": 19,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "Identifier",
+          "name": "egy",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 4
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 5
+                },
+                "end": {
+                  "line": 21,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 4
+            },
+            "end": {
+              "line": 21,
+              "column": 12
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "Identifier",
+          "name": "ketto",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 6
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [
+            {
+              "type": "UpdateExpression",
+              "operator": "++",
+              "prefix": false,
+              "argument": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 9
+                },
+                "end": {
+                  "line": 23,
+                  "column": 12
+                }
+              }
+            },
+            {
+              "type": "UpdateExpression",
+              "operator": "++",
+              "prefix": false,
+              "argument": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 15
+                },
+                "end": {
+                  "line": 23,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 7
+                },
+                "end": {
+                  "line": 23,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 13
+                },
+                "end": {
+                  "line": 23,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 19
+                },
+                "end": {
+                  "line": 23,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 6
+            },
+            "end": {
+              "line": 23,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "Identifier",
+          "name": "katica",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 7
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [
+            {
+              "type": "UpdateExpression",
+              "operator": "++",
+              "prefix": false,
+              "argument": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 14
+                },
+                "end": {
+                  "line": 25,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 12
+                }
+              }
+            },
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 18
+                },
+                "end": {
+                  "line": 25,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 7
+            },
+            "end": {
+              "line": 25,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "Identifier",
+          "name": "harom",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 1
+            },
+            "end": {
+              "line": 27,
+              "column": 6
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [
+            {
+              "type": "UpdateExpression",
+              "operator": "++",
+              "prefix": false,
+              "argument": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 9
+                },
+                "end": {
+                  "line": 27,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 7
+                },
+                "end": {
+                  "line": 27,
+                  "column": 7
+                }
+              }
+            },
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 13
+                },
+                "end": {
+                  "line": 27,
+                  "column": 15
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 6
+            },
+            "end": {
+              "line": 27,
+              "column": 16
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "Identifier",
+          "name": "kiskacsa",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 1
+            },
+            "end": {
+              "line": 29,
+              "column": 9
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 10
+                },
+                "end": {
+                  "line": 32,
+                  "column": 1
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 9
+            },
+            "end": {
+              "line": 32,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 32,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "Identifier",
+            "name": "alma",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 1
+              },
+              "end": {
+                "line": 34,
+                "column": 5
+              }
+            }
+          },
+          "arguments": [],
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 1
+            },
+            "end": {
+              "line": 34,
+              "column": 7
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 8
+                },
+                "end": {
+                  "line": 34,
+                  "column": 10
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 7
+            },
+            "end": {
+              "line": 34,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 1
+          },
+          "end": {
+            "line": 34,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "MemberExpression",
+          "object": {
+            "type": "Identifier",
+            "name": "alma",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 1
+              },
+              "end": {
+                "line": 36,
+                "column": 5
+              }
+            }
+          },
+          "property": {
+            "type": "StringLiteral",
+            "value": "",
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 6
+              },
+              "end": {
+                "line": 36,
+                "column": 8
+              }
+            }
+          },
+          "computed": true,
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 1
+            },
+            "end": {
+              "line": 36,
+              "column": 9
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 10
+                },
+                "end": {
+                  "line": 36,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 9
+            },
+            "end": {
+              "line": 36,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 1
+          },
+          "end": {
+            "line": 36,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TaggedTemplateExpression",
+        "tag": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "Identifier",
+              "name": "fa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 1
+                },
+                "end": {
+                  "line": 38,
+                  "column": 3
+                }
+              }
+            },
+            "property": {
+              "type": "TemplateLiteral",
+              "expressions": [],
+              "quasis": [
+                {
+                  "type": "TemplateElement",
+                  "value": {
+                    "raw": "",
+                    "cooked": ""
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 9
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 4
+                },
+                "end": {
+                  "line": 38,
+                  "column": 10
+                }
+              }
+            },
+            "computed": true,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 1
+              },
+              "end": {
+                "line": 38,
+                "column": 11
+              }
+            }
+          },
+          "arguments": [],
+          "optional": false,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 1
+            },
+            "end": {
+              "line": 38,
+              "column": 13
+            }
+          }
+        },
+        "quasi": {
+          "type": "TemplateLiteral",
+          "expressions": [],
+          "quasis": [
+            {
+              "type": "TemplateElement",
+              "value": {
+                "raw": "",
+                "cooked": ""
+              },
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 14
+                },
+                "end": {
+                  "line": 38,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 13
+            },
+            "end": {
+              "line": 38,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 1
+          },
+          "end": {
+            "line": 38,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 17
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 39,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-tagged-template-expression.js b/es2panda/test/parser/js/test-tagged-template-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e354661e4c1a3d372b9e87d7026c89d98201655
--- /dev/null
+++ b/es2panda/test/parser/js/test-tagged-template-expression.js
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+alma``
+
+fa`${a++}`
+
+egy`almafa`
+
+ketto`${a++}${b++}`
+
+katica`alma${b++}`
+
+harom`${b++}fa`
+
+kiskacsa`
+
+
+`
+
+alma()`fa`
+
+alma['']`fa`
+
+fa[`alma`]()`fa`
diff --git a/es2panda/test/parser/js/test-template-literal-1-expected.txt b/es2panda/test/parser/js/test-template-literal-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7b304e51e073558cde3bc947e2053dda3cfabedb
--- /dev/null
+++ b/es2panda/test/parser/js/test-template-literal-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unterminated string [test-template-literal-1.js:17:608]
diff --git a/es2panda/test/parser/js/test-template-literal-1.js b/es2panda/test/parser/js/test-template-literal-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..36ec7297fb0b26e68153b81e52713d62bdb19db9
--- /dev/null
+++ b/es2panda/test/parser/js/test-template-literal-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+`
diff --git a/es2panda/test/parser/js/test-template-literal-2-expected.txt b/es2panda/test/parser/js/test-template-literal-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c0cca85d5c7fac610655fb904886ddf3c9508a0d
--- /dev/null
+++ b/es2panda/test/parser/js/test-template-literal-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-template-literal-2.js:17:6]
diff --git a/es2panda/test/parser/js/test-template-literal-2.js b/es2panda/test/parser/js/test-template-literal-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..901edb627e04991390729ffcd8d435427497fe31
--- /dev/null
+++ b/es2panda/test/parser/js/test-template-literal-2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+fa`${}`
diff --git a/es2panda/test/parser/js/test-template-literal-expected.txt b/es2panda/test/parser/js/test-template-literal-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..96d0aabd855db80a35f556e5b094879a14b3fe8b
--- /dev/null
+++ b/es2panda/test/parser/js/test-template-literal-expected.txt
@@ -0,0 +1,622 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 2
+              },
+              "end": {
+                "line": 17,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [
+          {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "prefix": false,
+            "argument": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 4
+                },
+                "end": {
+                  "line": 19,
+                  "column": 5
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 4
+              },
+              "end": {
+                "line": 19,
+                "column": 7
+              }
+            }
+          }
+        ],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 2
+              },
+              "end": {
+                "line": 19,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 8
+              },
+              "end": {
+                "line": 19,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 2
+              },
+              "end": {
+                "line": 21,
+                "column": 8
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [
+          {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "prefix": false,
+            "argument": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 4
+                },
+                "end": {
+                  "line": 23,
+                  "column": 5
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 4
+              },
+              "end": {
+                "line": 23,
+                "column": 7
+              }
+            }
+          },
+          {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "prefix": false,
+            "argument": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 10
+                },
+                "end": {
+                  "line": 23,
+                  "column": 11
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 10
+              },
+              "end": {
+                "line": 23,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 2
+              },
+              "end": {
+                "line": 23,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 8
+              },
+              "end": {
+                "line": 23,
+                "column": 8
+              }
+            }
+          },
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 14
+              },
+              "end": {
+                "line": 23,
+                "column": 14
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [
+          {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "prefix": false,
+            "argument": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 8
+              },
+              "end": {
+                "line": 25,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 2
+              },
+              "end": {
+                "line": 25,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 12
+              },
+              "end": {
+                "line": 25,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [
+          {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "prefix": false,
+            "argument": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 4
+                },
+                "end": {
+                  "line": 27,
+                  "column": 5
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 4
+              },
+              "end": {
+                "line": 27,
+                "column": 7
+              }
+            }
+          }
+        ],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 2
+              },
+              "end": {
+                "line": 27,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 8
+              },
+              "end": {
+                "line": 27,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 1
+          },
+          "end": {
+            "line": 27,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 2
+              },
+              "end": {
+                "line": 32,
+                "column": 1
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 32,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 3
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "TemplateLiteral",
+        "expressions": [],
+        "quasis": [
+          {
+            "type": "TemplateElement",
+            "value": {
+              "raw": "",
+              "cooked": ""
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 2
+              },
+              "end": {
+                "line": 34,
+                "column": 10
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 1
+          },
+          "end": {
+            "line": 34,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 35,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-template-literal.js b/es2panda/test/parser/js/test-template-literal.js
new file mode 100644
index 0000000000000000000000000000000000000000..8bab078ea1795cc241e18bf5dbe684d58f663047
--- /dev/null
+++ b/es2panda/test/parser/js/test-template-literal.js
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+``;
+
+`${a++}`;
+
+`almafa`;
+
+`${a++}${b++}`;
+
+`alma${b++}`;
+
+`${b++}fa`;
+
+`
+
+
+`;
+
+`$ {alma}`;
diff --git a/es2panda/test/parser/js/test-this-expression-expected.txt b/es2panda/test/parser/js/test-this-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4329742c43234b995a663cb1a1f42e0b80d5b35f
--- /dev/null
+++ b/es2panda/test/parser/js/test-this-expression-expected.txt
@@ -0,0 +1,234 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "ThisExpression",
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 1
+            },
+            "end": {
+              "line": 17,
+              "column": 5
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 6
+            },
+            "end": {
+              "line": 17,
+              "column": 7
+            }
+          }
+        },
+        "computed": false,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "MemberExpression",
+        "object": {
+          "type": "ThisExpression",
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 5
+            }
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 6
+            },
+            "end": {
+              "line": 18,
+              "column": 7
+            }
+          }
+        },
+        "computed": true,
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "+",
+        "left": {
+          "type": "ThisExpression",
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "NumberLiteral",
+          "value": 5,
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 6
+            },
+            "end": {
+              "line": 19,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "ThisExpression",
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 1
+            },
+            "end": {
+              "line": 20,
+              "column": 5
+            }
+          }
+        },
+        "right": {
+          "type": "ThisExpression",
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 9
+            },
+            "end": {
+              "line": 20,
+              "column": 13
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 13
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 21,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-this-expression.js b/es2panda/test/parser/js/test-this-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1161118a48a53321c4b7473968ae9c576219106
--- /dev/null
+++ b/es2panda/test/parser/js/test-this-expression.js
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+this.a;
+this[a];
+this+5;
+this || this;
diff --git a/es2panda/test/parser/js/test-throw-statement-expected.txt b/es2panda/test/parser/js/test-throw-statement-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9c17104f1352ab9269006fe7ff3b5a714244b291
--- /dev/null
+++ b/es2panda/test/parser/js/test-throw-statement-expected.txt
@@ -0,0 +1,343 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "NumberLiteral",
+        "value": 123,
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 7
+          },
+          "end": {
+            "line": 17,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "NumberLiteral",
+        "value": 123,
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 7
+          },
+          "end": {
+            "line": 18,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 7
+          },
+          "end": {
+            "line": 19,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 7
+          },
+          "end": {
+            "line": 20,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 7
+          },
+          "end": {
+            "line": 21,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 7
+          },
+          "end": {
+            "line": 22,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "Identifier",
+        "name": "undefined",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 7
+          },
+          "end": {
+            "line": 23,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "Identifier",
+        "name": "undefined",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 7
+          },
+          "end": {
+            "line": 24,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "NullLiteral",
+        "value": null,
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 7
+          },
+          "end": {
+            "line": 25,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "NullLiteral",
+        "value": null,
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 7
+          },
+          "end": {
+            "line": 26,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "Identifier",
+        "name": "err",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 7
+          },
+          "end": {
+            "line": 27,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ThrowStatement",
+      "argument": {
+        "type": "Identifier",
+        "name": "err",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 7
+          },
+          "end": {
+            "line": 28,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 28,
+          "column": 11
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 29,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-throw-statement-without-expression-expected.txt b/es2panda/test/parser/js/test-throw-statement-without-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dd226101cb7162e261b0c07c008325136e121f40
--- /dev/null
+++ b/es2panda/test/parser/js/test-throw-statement-without-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-throw-statement-without-expression.js:17:7]
diff --git a/es2panda/test/parser/js/test-throw-statement-without-expression.js b/es2panda/test/parser/js/test-throw-statement-without-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d516647e6c4f8b175526c42325b6b2bc315783e
--- /dev/null
+++ b/es2panda/test/parser/js/test-throw-statement-without-expression.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+throw ;
diff --git a/es2panda/test/parser/js/test-throw-statement.js b/es2panda/test/parser/js/test-throw-statement.js
new file mode 100644
index 0000000000000000000000000000000000000000..a498337b26de7fe9fc27219542f3cd4b64ceafb8
--- /dev/null
+++ b/es2panda/test/parser/js/test-throw-statement.js
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+throw 123
+throw 123;
+throw ''
+throw '';
+throw ""
+throw "";
+throw undefined
+throw undefined;
+throw null
+throw null;
+throw err
+throw err;
diff --git a/es2panda/test/parser/js/test-try-catch-lexical-declaration-expected.txt b/es2panda/test/parser/js/test-try-catch-lexical-declaration-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c5556ff6baad7e810894bf1811423100f728bc06
--- /dev/null
+++ b/es2panda/test/parser/js/test-try-catch-lexical-declaration-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Variable 'e' has already been declared. [test-try-catch-lexical-declaration.js:23:7]
diff --git a/es2panda/test/parser/js/test-try-catch-lexical-declaration.js b/es2panda/test/parser/js/test-try-catch-lexical-declaration.js
new file mode 100644
index 0000000000000000000000000000000000000000..9660bb1a393bb813b38f2ae5629847963ddb15be
--- /dev/null
+++ b/es2panda/test/parser/js/test-try-catch-lexical-declaration.js
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+try
+{
+
+}
+catch(e)
+{
+  let e;
+}
+finally
+{
+
+}
diff --git a/es2panda/test/parser/js/test-try-statement-expected.txt b/es2panda/test/parser/js/test-try-statement-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..905a5b388d6a53d9275ac00dc04bc724765c94b9
--- /dev/null
+++ b/es2panda/test/parser/js/test-try-statement-expected.txt
@@ -0,0 +1,335 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TryStatement",
+      "block": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 5
+          },
+          "end": {
+            "line": 17,
+            "column": 8
+          }
+        }
+      },
+      "handler": {
+        "type": "CatchClause",
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 10
+            },
+            "end": {
+              "line": 18,
+              "column": 13
+            }
+          }
+        },
+        "param": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 7
+            },
+            "end": {
+              "line": 18,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 13
+          }
+        }
+      },
+      "finalizer": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 9
+          },
+          "end": {
+            "line": 19,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "TryStatement",
+      "block": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 5
+          },
+          "end": {
+            "line": 21,
+            "column": 8
+          }
+        }
+      },
+      "handler": {
+        "type": "CatchClause",
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 7
+            },
+            "end": {
+              "line": 22,
+              "column": 10
+            }
+          }
+        },
+        "param": null,
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 10
+          }
+        }
+      },
+      "finalizer": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 9
+          },
+          "end": {
+            "line": 23,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "TryStatement",
+      "block": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 5
+          },
+          "end": {
+            "line": 25,
+            "column": 8
+          }
+        }
+      },
+      "handler": null,
+      "finalizer": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 9
+          },
+          "end": {
+            "line": 26,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "TryStatement",
+      "block": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 5
+          },
+          "end": {
+            "line": 28,
+            "column": 8
+          }
+        }
+      },
+      "handler": {
+        "type": "CatchClause",
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 10
+            },
+            "end": {
+              "line": 29,
+              "column": 13
+            }
+          }
+        },
+        "param": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 7
+            },
+            "end": {
+              "line": 29,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 1
+          },
+          "end": {
+            "line": 29,
+            "column": 13
+          }
+        }
+      },
+      "finalizer": null,
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "TryStatement",
+      "block": {
+        "type": "BlockStatement",
+        "statements": [],
+        "loc": {
+          "start": {
+            "line": 31,
+            "column": 5
+          },
+          "end": {
+            "line": 31,
+            "column": 8
+          }
+        }
+      },
+      "handler": {
+        "type": "CatchClause",
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 7
+            },
+            "end": {
+              "line": 32,
+              "column": 10
+            }
+          }
+        },
+        "param": null,
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 1
+          },
+          "end": {
+            "line": 32,
+            "column": 10
+          }
+        }
+      },
+      "finalizer": null,
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 10
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 33,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-try-statement.js b/es2panda/test/parser/js/test-try-statement.js
new file mode 100644
index 0000000000000000000000000000000000000000..894a94f45a8ac6512d5c5292df20470ccda73dae
--- /dev/null
+++ b/es2panda/test/parser/js/test-try-statement.js
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+try { }
+catch(e) { }
+finally { }
+
+try { }
+catch { }
+finally { }
+
+try { }
+finally { }
+
+try { }
+catch(e) { }
+
+try { }
+catch { }
diff --git a/es2panda/test/parser/js/test-try-without-catch-and-finally-expected.txt b/es2panda/test/parser/js/test-try-without-catch-and-finally-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..15589f33010fe81dd64996c1cf5efada53e8c3d8
--- /dev/null
+++ b/es2panda/test/parser/js/test-try-without-catch-and-finally-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Missing catch or finally clause [test-try-without-catch-and-finally.js:18:1]
diff --git a/es2panda/test/parser/js/test-try-without-catch-and-finally.js b/es2panda/test/parser/js/test-try-without-catch-and-finally.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d55d5a81ab258bf3b877ff7ba99afc55c64f02b
--- /dev/null
+++ b/es2panda/test/parser/js/test-try-without-catch-and-finally.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+try { }
diff --git a/es2panda/test/parser/js/test-unary-expression-expected.txt b/es2panda/test/parser/js/test-unary-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..772dcc7b29d45430c86a9d01a2c82934bdc40236
--- /dev/null
+++ b/es2panda/test/parser/js/test-unary-expression-expected.txt
@@ -0,0 +1,519 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "+",
+        "prefix": true,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 2
+            },
+            "end": {
+              "line": 17,
+              "column": 3
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "-",
+        "prefix": true,
+        "argument": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 2
+            },
+            "end": {
+              "line": 18,
+              "column": 3
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "BinaryExpression",
+        "operator": "-",
+        "left": {
+          "type": "UnaryExpression",
+          "operator": "+",
+          "prefix": true,
+          "argument": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 2
+              },
+              "end": {
+                "line": 19,
+                "column": 3
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 3
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 2
+            },
+            "end": {
+              "line": 20,
+              "column": 3
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "!",
+        "prefix": true,
+        "argument": {
+          "type": "Identifier",
+          "name": "c",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 2
+            },
+            "end": {
+              "line": 21,
+              "column": 3
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 3
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "typeof",
+        "prefix": true,
+        "argument": {
+          "type": "Identifier",
+          "name": "d",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 8
+            },
+            "end": {
+              "line": 22,
+              "column": 9
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 1
+          },
+          "end": {
+            "line": 22,
+            "column": 9
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "void",
+        "prefix": true,
+        "argument": {
+          "type": "Identifier",
+          "name": "e",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 6
+            },
+            "end": {
+              "line": 23,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "delete",
+        "prefix": true,
+        "argument": {
+          "type": "NumberLiteral",
+          "value": 12,
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 8
+            },
+            "end": {
+              "line": 24,
+              "column": 10
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "UnaryExpression",
+          "operator": "!",
+          "prefix": true,
+          "argument": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 2
+              },
+              "end": {
+                "line": 25,
+                "column": 3
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 1
+            },
+            "end": {
+              "line": 25,
+              "column": 3
+            }
+          }
+        },
+        "right": {
+          "type": "LogicalExpression",
+          "operator": "&&",
+          "left": {
+            "type": "UnaryExpression",
+            "operator": "~",
+            "prefix": true,
+            "argument": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 7
+              },
+              "end": {
+                "line": 25,
+                "column": 9
+              }
+            }
+          },
+          "right": {
+            "type": "BinaryExpression",
+            "operator": "+",
+            "left": {
+              "type": "UnaryExpression",
+              "operator": "+",
+              "prefix": true,
+              "argument": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 13
+                },
+                "end": {
+                  "line": 25,
+                  "column": 15
+                }
+              }
+            },
+            "right": {
+              "type": "UnaryExpression",
+              "operator": "-",
+              "prefix": true,
+              "argument": {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 18
+                },
+                "end": {
+                  "line": 25,
+                  "column": 20
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 13
+              },
+              "end": {
+                "line": 25,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 7
+            },
+            "end": {
+              "line": 25,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 25,
+            "column": 1
+          },
+          "end": {
+            "line": 25,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 25,
+      "column": 20
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-unary-expression.js b/es2panda/test/parser/js/test-unary-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..64c8ee67cfc7ec70e61f539e6237cb45c34ef4bb
--- /dev/null
+++ b/es2panda/test/parser/js/test-unary-expression.js
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
++a;
+-b;
++a
+-b;
+!c
+typeof d
+void e
+delete 12
+!a || ~b && +c + -d
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-update-expression-expected.txt b/es2panda/test/parser/js/test-update-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2a6a04fef3007426f1c60be9122ab17f87df98f2
--- /dev/null
+++ b/es2panda/test/parser/js/test-update-expression-expected.txt
@@ -0,0 +1,363 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": true,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 3
+            },
+            "end": {
+              "line": 17,
+              "column": 4
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 1
+          },
+          "end": {
+            "line": 17,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "UpdateExpression",
+          "operator": "++",
+          "prefix": true,
+          "argument": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 3
+              },
+              "end": {
+                "line": 18,
+                "column": 4
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 4
+            }
+          }
+        },
+        "right": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 6
+            },
+            "end": {
+              "line": 18,
+              "column": 7
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 1
+          },
+          "end": {
+            "line": 18,
+            "column": 7
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": false,
+        "argument": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 1
+            },
+            "end": {
+              "line": 19,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 1
+          },
+          "end": {
+            "line": 19,
+            "column": 4
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 4
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UnaryExpression",
+        "operator": "!",
+        "prefix": true,
+        "argument": {
+          "type": "UpdateExpression",
+          "operator": "++",
+          "prefix": false,
+          "argument": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 2
+              },
+              "end": {
+                "line": 20,
+                "column": 3
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 2
+            },
+            "end": {
+              "line": 20,
+              "column": 5
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 1
+          },
+          "end": {
+            "line": 20,
+            "column": 5
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 5
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": {
+          "type": "UnaryExpression",
+          "operator": "~",
+          "prefix": true,
+          "argument": {
+            "type": "UnaryExpression",
+            "operator": "!",
+            "prefix": true,
+            "argument": {
+              "type": "UpdateExpression",
+              "operator": "++",
+              "prefix": false,
+              "argument": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 3
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 4
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 3
+                },
+                "end": {
+                  "line": 21,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 2
+              },
+              "end": {
+                "line": 21,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 1
+            },
+            "end": {
+              "line": 21,
+              "column": 6
+            }
+          }
+        },
+        "right": {
+          "type": "UnaryExpression",
+          "operator": "!",
+          "prefix": true,
+          "argument": {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "prefix": false,
+            "argument": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 11
+                },
+                "end": {
+                  "line": 21,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 11
+              },
+              "end": {
+                "line": 21,
+                "column": 14
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 10
+            },
+            "end": {
+              "line": 21,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 1
+          },
+          "end": {
+            "line": 21,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 14
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 21,
+      "column": 14
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-update-expression.js b/es2panda/test/parser/js/test-update-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..5eb9e7e4c48716cbf758f4d52ee475aa35739e2b
--- /dev/null
+++ b/es2panda/test/parser/js/test-update-expression.js
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+++a
+++a||b;
+a++
+!a++
+~!a++ && !b++
\ No newline at end of file
diff --git a/es2panda/test/parser/js/test-use-strict-1-expected.txt b/es2panda/test/parser/js/test-use-strict-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aa8dea3034f7d75bff70d57c5b12f4fc0c85bd0f
--- /dev/null
+++ b/es2panda/test/parser/js/test-use-strict-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Implicit octal literal not allowed [test-use-strict-1.js:18:629]
diff --git a/es2panda/test/parser/js/test-use-strict-1.js b/es2panda/test/parser/js/test-use-strict-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..27f3e2a9ef8dc29b39f0a7cf7ad349c63f77063a
--- /dev/null
+++ b/es2panda/test/parser/js/test-use-strict-1.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+"use strict"
+
+var a = 078;
diff --git a/es2panda/test/parser/js/test-use-strict-2-expected.txt b/es2panda/test/parser/js/test-use-strict-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b0f91c1ce6c64296afa13af6411f05c9c6a43862
--- /dev/null
+++ b/es2panda/test/parser/js/test-use-strict-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-use-strict-2.js:19:1]
diff --git a/es2panda/test/parser/js/test-use-strict-2.js b/es2panda/test/parser/js/test-use-strict-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..c9876d05a67f7f41170517ac5d05a0d3106aab7f
--- /dev/null
+++ b/es2panda/test/parser/js/test-use-strict-2.js
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+'use strict'
+
+with (o) {}
diff --git a/es2panda/test/parser/js/test-var-decl-expected.txt b/es2panda/test/parser/js/test-var-decl-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..304c634665a1135363f1b110d00758e16c1c2309
--- /dev/null
+++ b/es2panda/test/parser/js/test-var-decl-expected.txt
@@ -0,0 +1,468 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 5
+              },
+              "end": {
+                "line": 18,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 5
+            },
+            "end": {
+              "line": 18,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 7
+              },
+              "end": {
+                "line": 19,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 11
+              },
+              "end": {
+                "line": 19,
+                "column": 12
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 12
+            }
+          }
+        }
+      ],
+      "kind": "const",
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 7
+            }
+          }
+        },
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 10
+              },
+              "end": {
+                "line": 21,
+                "column": 12
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 10
+            },
+            "end": {
+              "line": 21,
+              "column": 12
+            }
+          }
+        },
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 3
+              },
+              "end": {
+                "line": 22,
+                "column": 5
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 3
+            },
+            "end": {
+              "line": 22,
+              "column": 5
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 5
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "Identifier",
+        "name": "d4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 3
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 3
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 7
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 2,
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 10
+              },
+              "end": {
+                "line": 25,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 11
+            }
+          }
+        },
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 13
+              },
+              "end": {
+                "line": 25,
+                "column": 15
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 13
+            },
+            "end": {
+              "line": 25,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 5
+              },
+              "end": {
+                "line": 27,
+                "column": 7
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 27,
+              "column": 5
+            },
+            "end": {
+              "line": 27,
+              "column": 7
+            }
+          }
+        },
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 3
+              },
+              "end": {
+                "line": 29,
+                "column": 5
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 3,
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 8
+              },
+              "end": {
+                "line": 29,
+                "column": 9
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 3
+            },
+            "end": {
+              "line": 29,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 31,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/js/test-var-decl.js b/es2panda/test/parser/js/test-var-decl.js
new file mode 100644
index 0000000000000000000000000000000000000000..b71805b791c1817b3f7ea627c987d66c422f945d
--- /dev/null
+++ b/es2panda/test/parser/js/test-var-decl.js
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+let a;
+var b
+const c = 1;
+
+var d1,  d2,
+  d3
+d4
+
+var e1 = 2, e2;
+
+var f1
+ ,
+  f2 = 3
+;
diff --git a/es2panda/test/parser/js/test-wrong-function-decl-1-expected.txt b/es2panda/test/parser/js/test-wrong-function-decl-1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..76d7752a8831d7591da2073522ba16ad0689a8b6
--- /dev/null
+++ b/es2panda/test/parser/js/test-wrong-function-decl-1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected '(' [test-wrong-function-decl-1.js:17:11]
diff --git a/es2panda/test/parser/js/test-wrong-function-decl-1.js b/es2panda/test/parser/js/test-wrong-function-decl-1.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9b15e557d7f42f583b2f7744420868259124a0e
--- /dev/null
+++ b/es2panda/test/parser/js/test-wrong-function-decl-1.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function f{}
diff --git a/es2panda/test/parser/js/test-wrong-function-decl-2-expected.txt b/es2panda/test/parser/js/test-wrong-function-decl-2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1ec040f3e88541122bc5f27f6c8d4656a46011c3
--- /dev/null
+++ b/es2panda/test/parser/js/test-wrong-function-decl-2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected '{' [test-wrong-function-decl-2.js:17:18]
diff --git a/es2panda/test/parser/js/test-wrong-function-decl-2.js b/es2panda/test/parser/js/test-wrong-function-decl-2.js
new file mode 100644
index 0000000000000000000000000000000000000000..d30d1c0d3d53b65f63e1d2f7730a8ca54c38f949
--- /dev/null
+++ b/es2panda/test/parser/js/test-wrong-function-decl-2.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function f(a,b,c);
diff --git a/es2panda/test/parser/js/test-wrong-function-decl-3-expected.txt b/es2panda/test/parser/js/test-wrong-function-decl-3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a7b3e14568692e19c5d5188179944781d012a3e
--- /dev/null
+++ b/es2panda/test/parser/js/test-wrong-function-decl-3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Primary expression expected [test-wrong-function-decl-3.js:19:5]
diff --git a/es2panda/test/parser/js/test-wrong-function-decl-3.js b/es2panda/test/parser/js/test-wrong-function-decl-3.js
new file mode 100644
index 0000000000000000000000000000000000000000..affdc2540cb7e4faf5bbd558e50b28190ba4ecaf
--- /dev/null
+++ b/es2panda/test/parser/js/test-wrong-function-decl-3.js
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function f(p1, p2, p3)
+{
+  a[;
+}
diff --git a/es2panda/test/parser/js/this-expression-expected.txt b/es2panda/test/parser/js/this-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..71b1c81cb50ce1e9b70cf1024c1cf38f98fcaf14
--- /dev/null
+++ b/es2panda/test/parser/js/this-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Expected an identifier [this-expression.js:17:6]
diff --git a/es2panda/test/parser/js/this-expression.js b/es2panda/test/parser/js/this-expression.js
new file mode 100644
index 0000000000000000000000000000000000000000..482c29c947d5b4fdbd5ec179d823f057be746836
--- /dev/null
+++ b/es2panda/test/parser/js/this-expression.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+this."foo";
diff --git a/es2panda/test/parser/ts/test-arrow-function-expected.txt b/es2panda/test/parser/ts/test-arrow-function-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b843eaa8bb033140aa2a190cdcef69de8678310
--- /dev/null
+++ b/es2panda/test/parser/ts/test-arrow-function-expected.txt
@@ -0,0 +1,363 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": false,
+          "expression": false,
+          "params": [
+            {
+              "type": "Identifier",
+              "name": "y",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 12
+                  }
+                }
+              },
+              "optional": true,
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "body": {
+            "type": "BlockStatement",
+            "statements": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 17
+              },
+              "end": {
+                "line": 1,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 20
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 20
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": false,
+          "expression": false,
+          "params": [
+            {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 11
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 2
+                },
+                "end": {
+                  "line": 2,
+                  "column": 3
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "y",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 23
+                  }
+                }
+              },
+              "optional": true,
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 13
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "body": {
+            "type": "BlockStatement",
+            "statements": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 28
+              },
+              "end": {
+                "line": 2,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 31
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 31
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": false,
+          "expression": false,
+          "params": [
+            {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 11
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 2
+                },
+                "end": {
+                  "line": 3,
+                  "column": 3
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "y",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 22
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 13
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            {
+              "type": "Identifier",
+              "name": "z",
+              "typeAnnotation": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 35
+                  }
+                }
+              },
+              "optional": true,
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 24
+                },
+                "end": {
+                  "line": 3,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "body": {
+            "type": "BlockStatement",
+            "statements": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 40
+              },
+              "end": {
+                "line": 3,
+                "column": 43
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 43
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 43
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 44
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 44
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-arrow-function.ts b/es2panda/test/parser/ts/test-arrow-function.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f63f613709bd7aeab0497407fa99fca624839da3
--- /dev/null
+++ b/es2panda/test/parser/ts/test-arrow-function.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+(y?: number) => { }
+(x: number, y?: number) => { };
+(x: number, y: number, z?: boolean) => { };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-as-expression-expected.txt b/es2panda/test/parser/ts/test-as-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fe5dd740e4c0c580ec3d2a2ccf86efcffd20c664
--- /dev/null
+++ b/es2panda/test/parser/ts/test-as-expression-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-as-expression.ts:1:13]
diff --git a/es2panda/test/parser/ts/test-as-expression.ts b/es2panda/test/parser/ts/test-as-expression.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fcb85d0f33cf75511feee903ee13af3e86bc5c95
--- /dev/null
+++ b/es2panda/test/parser/ts/test-as-expression.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = 5 as;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-constructor-expected.txt b/es2panda/test/parser/ts/test-class-constructor-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..56ce85bab51f4b60f1910da09dfabd5fe73410f6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor-expected.txt
@@ -0,0 +1,916 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Baz",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 7
+            },
+            "end": {
+              "line": 1,
+              "column": 10
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 16
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "s",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "n",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 30
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "ExpressionStatement",
+                    "expression": {
+                      "type": "AssignmentExpression",
+                      "operator": "=",
+                      "left": {
+                        "type": "MemberExpression",
+                        "object": {
+                          "type": "ThisExpression",
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "property": {
+                          "type": "Identifier",
+                          "name": "s",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "computed": false,
+                        "optional": false,
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "LogicalExpression",
+                        "operator": "||",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "s",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "StringLiteral",
+                          "value": "",
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 25
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 25
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 26
+                      }
+                    }
+                  },
+                  {
+                    "type": "ExpressionStatement",
+                    "expression": {
+                      "type": "AssignmentExpression",
+                      "operator": "=",
+                      "left": {
+                        "type": "MemberExpression",
+                        "object": {
+                          "type": "ThisExpression",
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "property": {
+                          "type": "Identifier",
+                          "name": "n",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "computed": false,
+                        "optional": false,
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "LogicalExpression",
+                        "operator": "||",
+                        "left": {
+                          "type": "Identifier",
+                          "name": "n",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "NumberLiteral",
+                          "value": 0,
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 25
+                      }
+                    }
+                  },
+                  {
+                    "type": "ExpressionStatement",
+                    "expression": {
+                      "type": "CallExpression",
+                      "callee": {
+                        "type": "MemberExpression",
+                        "object": {
+                          "type": "ThisExpression",
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "property": {
+                          "type": "Identifier",
+                          "name": "f",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 9,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 9,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "computed": false,
+                        "optional": false,
+                        "loc": {
+                          "start": {
+                            "line": 9,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 9,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "arguments": [],
+                      "optional": false,
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 18
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 6
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 16
+                },
+                "end": {
+                  "line": 10,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 16
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "overloads": [
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "Identifier",
+                "name": "constructor",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "constructor",
+              "static": false,
+              "optional": false,
+              "computed": false,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "s",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 18
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 29
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 29
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 29
+                }
+              }
+            },
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "Identifier",
+                "name": "constructor",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "constructor",
+              "static": false,
+              "optional": false,
+              "computed": false,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 19
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 19
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 5
+                },
+                "end": {
+                  "line": 5,
+                  "column": 19
+                }
+              }
+            }
+          ],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "s",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "n",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "f",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 5
+                },
+                "end": {
+                  "line": 11,
+                  "column": 6
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "TSVoidKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 14
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ExpressionStatement",
+                      "expression": {
+                        "type": "UpdateExpression",
+                        "operator": "++",
+                        "prefix": false,
+                        "argument": {
+                          "type": "MemberExpression",
+                          "object": {
+                            "type": "ThisExpression",
+                            "loc": {
+                              "start": {
+                                "line": 12,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 12,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "property": {
+                            "type": "Identifier",
+                            "name": "n",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 12,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 12,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "computed": false,
+                          "optional": false,
+                          "loc": {
+                            "start": {
+                              "line": 12,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 12,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 12,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 18
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 6
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 6
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 6
+                },
+                "end": {
+                  "line": 13,
+                  "column": 6
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 6
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 14,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 14,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-class-constructor.ts b/es2panda/test/parser/ts/test-class-constructor.ts
new file mode 100644
index 0000000000000000000000000000000000000000..82d5e368cda0c5daa69301a2df181d79d6abde88
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor.ts
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Baz {
+    s: string;
+    n: number;
+    constructor(s?: string);
+    constructor();
+    constructor(s?: string, n?: number) {
+        this.s = s || "";
+        this.n = n || 0;
+        this.f();
+    };
+    f(): void {
+        this.n++;
+    };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-constructor1-expected.txt b/es2panda/test/parser/ts/test-class-constructor1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aeb92469fa04442d1fbb6c8f59b2c16a73ac0400
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Constructor implementation is missing. [test-class-constructor1.ts:2:5]
diff --git a/es2panda/test/parser/ts/test-class-constructor1.ts b/es2panda/test/parser/ts/test-class-constructor1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..439762c98f810d4876252cebc7d51e773d97e686
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor1.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor();
+    a: string;
+    constructor() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-constructor2-expected.txt b/es2panda/test/parser/ts/test-class-constructor2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..63be2e9e88aac6c2e99088591dc6f7c788b1049e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Constructor implementation is missing. [test-class-constructor2.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-constructor2.ts b/es2panda/test/parser/ts/test-class-constructor2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..420f9d432613e148d405bc1488bbbea02ce36f10
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor2.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor();
+    constructor() { };
+    b: string;
+    constructor();
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-constructor3-expected.txt b/es2panda/test/parser/ts/test-class-constructor3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..102229c513bbcb47008c71a211f8d6cf908b621b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '(' expected [test-class-constructor3.ts:2:16]
diff --git a/es2panda/test/parser/ts/test-class-constructor3.ts b/es2panda/test/parser/ts/test-class-constructor3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fe4ce5e15a837bc3fb7d10d06903cb9ccc09d96d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor?() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-constructor4-expected.txt b/es2panda/test/parser/ts/test-class-constructor4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4f3dc6d7fa8defefdeb8e037062473a1cf068da0
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Constructor implementation is missing. [test-class-constructor4.ts:2:5]
diff --git a/es2panda/test/parser/ts/test-class-constructor4.ts b/es2panda/test/parser/ts/test-class-constructor4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..884f24519ebf592938db8c2d00dfef084237273a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor();
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-constructor5-expected.txt b/es2panda/test/parser/ts/test-class-constructor5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5f7e7b36a4825f07b8d08d07b1a8a6ebfd9724dc
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Multiple constructor implementations are not allowed. [test-class-constructor5.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-constructor5.ts b/es2panda/test/parser/ts/test-class-constructor5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4650afdf632b7a28fe89aa95d9fdb4f2669c99c0
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-constructor5.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor() { };
+    constructor() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definition-expected.txt b/es2panda/test/parser/ts/test-class-definition-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5867877ee35ed26ed421bd0c144600cb967eaca6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definition-expected.txt
@@ -0,0 +1,2384 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 7
+            },
+            "end": {
+              "line": 1,
+              "column": 10
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 16,
+              "column": 2
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 24
+                },
+                "end": {
+                  "line": 2,
+                  "column": 25
+                }
+              }
+            },
+            "kind": "get",
+            "accessibility": "private",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": null,
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 36
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 38
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 38
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 25
+                },
+                "end": {
+                  "line": 2,
+                  "column": 38
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 38
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "g",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 19
+                },
+                "end": {
+                  "line": 3,
+                  "column": 20
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": true,
+                "async": true,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 26
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 20
+                },
+                "end": {
+                  "line": 3,
+                  "column": 26
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 30
+                },
+                "end": {
+                  "line": 4,
+                  "column": 31
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 31
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 30
+                },
+                "end": {
+                  "line": 5,
+                  "column": 33
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 33
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 67,
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 29
+                },
+                "end": {
+                  "line": 6,
+                  "column": 31
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 31
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "j",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 29
+                },
+                "end": {
+                  "line": 7,
+                  "column": 30
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 30
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "private",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 8,
+                  "column": 12
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 12
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 17
+                },
+                "end": {
+                  "line": 9,
+                  "column": 18
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "protected",
+            "static": false,
+            "optional": false,
+            "computed": true,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": true,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 25
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 19
+                },
+                "end": {
+                  "line": 9,
+                  "column": 25
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "k",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 19
+                },
+                "end": {
+                  "line": 10,
+                  "column": 20
+                }
+              }
+            },
+            "value": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 23
+                },
+                "end": {
+                  "line": 10,
+                  "column": 28
+                }
+              }
+            },
+            "accessibility": "public",
+            "static": true,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "TSPrivateIdentifier",
+              "key": {
+                "type": "Identifier",
+                "name": "o",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 7
+                  }
+                }
+              },
+              "value": {
+                "type": "NumberLiteral",
+                "value": 4,
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 5
+                },
+                "end": {
+                  "line": 11,
+                  "column": 7
+                }
+              }
+            },
+            "value": {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 10
+                },
+                "end": {
+                  "line": 11,
+                  "column": 11
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "l",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 9
+                },
+                "end": {
+                  "line": 12,
+                  "column": 10
+                }
+              }
+            },
+            "kind": "set",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 12
+                      }
+                    }
+                  }
+                ],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 25
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 10
+                },
+                "end": {
+                  "line": 12,
+                  "column": 25
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "l",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 16
+                },
+                "end": {
+                  "line": 13,
+                  "column": 17
+                }
+              }
+            },
+            "kind": "get",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 32
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 17
+                },
+                "end": {
+                  "line": 13,
+                  "column": 32
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 32
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "m",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 16
+                },
+                "end": {
+                  "line": 14,
+                  "column": 17
+                }
+              }
+            },
+            "kind": "get",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 2,
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 32
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 17
+                },
+                "end": {
+                  "line": 14,
+                  "column": 32
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 32
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "m",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 19
+                },
+                "end": {
+                  "line": 15,
+                  "column": 20
+                }
+              }
+            },
+            "kind": "set",
+            "accessibility": "protected",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 15,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 15,
+                          "column": 30
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 22
+                      }
+                    }
+                  }
+                ],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 35
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 35
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 20
+                },
+                "end": {
+                  "line": 15,
+                  "column": 35
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 15,
+                "column": 35
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Bar",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 7
+            },
+            "end": {
+              "line": 18,
+              "column": 10
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 1
+            },
+            "end": {
+              "line": 18,
+              "column": 66
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 13
+                },
+                "end": {
+                  "line": 18,
+                  "column": 14
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 13
+              },
+              "end": {
+                "line": 18,
+                "column": 14
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "d",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 16
+                },
+                "end": {
+                  "line": 18,
+                  "column": 17
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 18,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 23
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 17
+                },
+                "end": {
+                  "line": 18,
+                  "column": 23
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 16
+              },
+              "end": {
+                "line": 18,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "e",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 24
+                },
+                "end": {
+                  "line": 18,
+                  "column": 25
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 24
+              },
+              "end": {
+                "line": 18,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "let",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 27
+                },
+                "end": {
+                  "line": 18,
+                  "column": 30
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 27
+              },
+              "end": {
+                "line": 18,
+                "column": 30
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "var",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 32
+                },
+                "end": {
+                  "line": 18,
+                  "column": 35
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 32
+              },
+              "end": {
+                "line": 18,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "const",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 37
+                },
+                "end": {
+                  "line": 18,
+                  "column": 42
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 37
+              },
+              "end": {
+                "line": 18,
+                "column": 42
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "function",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 44
+                },
+                "end": {
+                  "line": 18,
+                  "column": 52
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 44
+              },
+              "end": {
+                "line": 18,
+                "column": 52
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "f",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 54
+                },
+                "end": {
+                  "line": 18,
+                  "column": 55
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 58
+                },
+                "end": {
+                  "line": 18,
+                  "column": 64
+                }
+              }
+            },
+            "definite": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 54
+              },
+              "end": {
+                "line": 18,
+                "column": 55
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 11
+          },
+          "end": {
+            "line": 18,
+            "column": 66
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 66
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Baz",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 10
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 5
+              },
+              "end": {
+                "line": 22,
+                "column": 16
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "name",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "ExpressionStatement",
+                    "expression": {
+                      "type": "AssignmentExpression",
+                      "operator": "=",
+                      "left": {
+                        "type": "MemberExpression",
+                        "object": {
+                          "type": "ThisExpression",
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "property": {
+                          "type": "TSPrivateIdentifier",
+                          "key": {
+                            "type": "Identifier",
+                            "name": "name",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 23,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 23,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "computed": false,
+                        "optional": false,
+                        "loc": {
+                          "start": {
+                            "line": 23,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 23,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "right": {
+                        "type": "Identifier",
+                        "name": "name",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 23,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 23,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 26
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 27
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 6
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 16
+                },
+                "end": {
+                  "line": 24,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 16
+              },
+              "end": {
+                "line": 24,
+                "column": 6
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 5
+            },
+            "end": {
+              "line": 24,
+              "column": 6
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "TSPrivateIdentifier",
+              "key": {
+                "type": "Identifier",
+                "name": "name",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 10
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 5
+                },
+                "end": {
+                  "line": 21,
+                  "column": 10
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 12
+                },
+                "end": {
+                  "line": 21,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "bar",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 5
+                },
+                "end": {
+                  "line": 25,
+                  "column": 8
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "MemberExpression",
+                        "object": {
+                          "type": "ThisExpression",
+                          "loc": {
+                            "start": {
+                              "line": 25,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 25,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "property": {
+                          "type": "TSPrivateIdentifier",
+                          "key": {
+                            "type": "Identifier",
+                            "name": "name",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 25,
+                                "column": 26
+                              },
+                              "end": {
+                                "line": 25,
+                                "column": 30
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 25,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 25,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "computed": false,
+                        "optional": false,
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 32
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 32
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 32
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 11
+          },
+          "end": {
+            "line": 26,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Inga",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 16
+            },
+            "end": {
+              "line": 28,
+              "column": 20
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 10
+            },
+            "end": {
+              "line": 31,
+              "column": 2
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 14
+                },
+                "end": {
+                  "line": 29,
+                  "column": 15
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 15
+                },
+                "end": {
+                  "line": 29,
+                  "column": 18
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "aa",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 5
+                },
+                "end": {
+                  "line": 30,
+                  "column": 7
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 13
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 7
+                },
+                "end": {
+                  "line": 30,
+                  "column": 13
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 15
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 18
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 5
+              },
+              "end": {
+                "line": 30,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 21
+          },
+          "end": {
+            "line": 31,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 10
+        },
+        "end": {
+          "line": 31,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 32,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-class-definition.ts b/es2panda/test/parser/ts/test-class-definition.ts
new file mode 100644
index 0000000000000000000000000000000000000000..19f474c93565ccc3096a63d34d0f27c0fc1cc504
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definition.ts
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    private static get a() { return }
+    public async *g() { }
+    static declare readonly [5]
+    static declare readonly ["b"]
+    static readonly declare 67
+    declare static readonly j
+    private;
+    protected *[1]() { }
+    public static k = "bar"
+    #o = 4;
+    set l(b: number) { };
+    public get l() { return 2 };
+    public get m() { return 2 };
+    protected set m(b: number) { };
+}
+
+class Bar { c; d() { } e; let; var; const; function; f!: number }
+
+class Baz {
+    #name: string;
+    constructor(name: string) {
+        this.#name = name;
+    }
+    bar() { return this.#name };
+}
+
+abstract class Inga {
+    abstract a();
+    aa() { };
+}
diff --git a/es2panda/test/parser/ts/test-class-definiton1-expected.txt b/es2panda/test/parser/ts/test-class-definiton1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..26faf8ae33e84674a240c4f461ce21a748d11a80
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Static modifier can not appear on a constructor [test-class-definiton1.ts:2:12]
diff --git a/es2panda/test/parser/ts/test-class-definiton1.ts b/es2panda/test/parser/ts/test-class-definiton1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f47f6308ce4c43ae2c3b56456d6e1eb518b83720
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    static constructor() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton10-expected.txt b/es2panda/test/parser/ts/test-class-definiton10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..27d0e3d1082197a3b36a5f91230831feb7afdf00
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton10-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected. [test-class-definiton10.ts:2:63]
diff --git a/es2panda/test/parser/ts/test-class-definiton10.ts b/es2panda/test/parser/ts/test-class-definiton10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..acd60b022150028af49e59c64c5c844925973d35
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    a() { } b() { } c() { } private static readonly declare d e;
+}
diff --git a/es2panda/test/parser/ts/test-class-definiton11-expected.txt b/es2panda/test/parser/ts/test-class-definiton11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ac5c9b5ab05dd2a3515928317465e3b453338ac3
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton11-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected. [test-class-definiton11.ts:2:11]
diff --git a/es2panda/test/parser/ts/test-class-definiton11.ts b/es2panda/test/parser/ts/test-class-definiton11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..191ea09d860dbff45487904f91518c607e1cc400
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    const a = 3;
+}
diff --git a/es2panda/test/parser/ts/test-class-definiton12-expected.txt b/es2panda/test/parser/ts/test-class-definiton12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a3cabafd81734f06893cb35dad12170f6bf8ed2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton12-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected. [test-class-definiton12.ts:2:9]
diff --git a/es2panda/test/parser/ts/test-class-definiton12.ts b/es2panda/test/parser/ts/test-class-definiton12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..257c51111f65d97f487d908151b5d12d2cfabe82
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    var a = 3;
+}
diff --git a/es2panda/test/parser/ts/test-class-definiton13-expected.txt b/es2panda/test/parser/ts/test-class-definiton13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..896dd0871b7d1c770e7b70c39e7ba0844f69a103
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton13-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected. [test-class-definiton13.ts:2:9]
diff --git a/es2panda/test/parser/ts/test-class-definiton13.ts b/es2panda/test/parser/ts/test-class-definiton13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b705c668f72e869e25b06ab2cb6460c2ab5a1c33
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton13.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    let a = 3;
+}
diff --git a/es2panda/test/parser/ts/test-class-definiton14-expected.txt b/es2panda/test/parser/ts/test-class-definiton14-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7bd6f06568ffb68e648284066f737d49d5070450
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton14-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected. [test-class-definiton14.ts:2:14]
diff --git a/es2panda/test/parser/ts/test-class-definiton14.ts b/es2panda/test/parser/ts/test-class-definiton14.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ea1eea4f1d6c84c412b38de99600c0655a83eb52
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton14.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    function a();
+}
diff --git a/es2panda/test/parser/ts/test-class-definiton15-expected.txt b/es2panda/test/parser/ts/test-class-definiton15-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b5b7039a81257d7e6555c07407c1e97090ab7372
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton15-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A get accessor must be at least as accessible as the setter [test-class-definiton15.ts:2:9]
diff --git a/es2panda/test/parser/ts/test-class-definiton15.ts b/es2panda/test/parser/ts/test-class-definiton15.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2e0ac2657bedc730ce57df5d663be06cb5ffdd6e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton15.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    set 5(k) { }
+    private get 5() { return }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton16-expected.txt b/es2panda/test/parser/ts/test-class-definiton16-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..47837ca26d8e82a91d86d80f91f810b768deb648
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton16-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A get accessor must be at least as accessible as the setter [test-class-definiton16.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-class-definiton16.ts b/es2panda/test/parser/ts/test-class-definiton16.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6395c69a33a17dac3f5e8376ce2fd7ad8c570fb9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton16.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    private get 5() { return }
+    protected set 5(k) { }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton17-expected.txt b/es2panda/test/parser/ts/test-class-definiton17-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e0e67d58f4b013aa221cfa4996712f71f4d2a5b0
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton17-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Abstract methods can only appear within an abstract class. [test-class-definiton17.ts:2:14]
diff --git a/es2panda/test/parser/ts/test-class-definiton17.ts b/es2panda/test/parser/ts/test-class-definiton17.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7a8cf7096ce7998bcb3941332d33d53cfc266e9f
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton17.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    abstract a()
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton18-expected.txt b/es2panda/test/parser/ts/test-class-definiton18-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e8ff92e4a20b068be031bb1e5daca583cc4398c4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton18-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Overload signatures must all be abstract or non-abstract. [test-class-definiton18.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-definiton18.ts b/es2panda/test/parser/ts/test-class-definiton18.ts
new file mode 100644
index 0000000000000000000000000000000000000000..700141124ffe25e37cac6a1e73c96e6983065f91
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton18.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+abstract class Foo {
+    a();
+    abstract a();
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton2-expected.txt b/es2panda/test/parser/ts/test-class-definiton2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..09f2fdad910a32e7c67e5b8101b5867801c13557
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Class method can not be declare nor readonly [test-class-definiton2.ts:2:25]
diff --git a/es2panda/test/parser/ts/test-class-definiton2.ts b/es2panda/test/parser/ts/test-class-definiton2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e9068eebbf9eac88e204c5fb0fc70b9ab8b8e74c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    private readonly [a](){}
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton3-expected.txt b/es2panda/test/parser/ts/test-class-definiton3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..45b732733138ccc7638ca1eb1d574cda2366cffa
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected modifier [test-class-definiton3.ts:2:12]
diff --git a/es2panda/test/parser/ts/test-class-definiton3.ts b/es2panda/test/parser/ts/test-class-definiton3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5f129be02fa8c17ac4f55a519f73afee2c62e230
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    static static a;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton4-expected.txt b/es2panda/test/parser/ts/test-class-definiton4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..45ffef742b0ebef4ec27547d8043d943b8f69c4a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Expected '(' [test-class-definiton4.ts:2:7]
diff --git a/es2panda/test/parser/ts/test-class-definiton4.ts b/es2panda/test/parser/ts/test-class-definiton4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f73cdc808f2541c88b8d1f5c66a821717cdaeb8b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    *b;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton5-expected.txt b/es2panda/test/parser/ts/test-class-definiton5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fc73a03ed431f78bc88b457a1b6a0f6154dcf19d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected modifier [test-class-definiton5.ts:2:14]
diff --git a/es2panda/test/parser/ts/test-class-definiton5.ts b/es2panda/test/parser/ts/test-class-definiton5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..12b2b010d04e03038229f035caf544067f695a5b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    readonly static a = "foo";
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton6-expected.txt b/es2panda/test/parser/ts/test-class-definiton6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7ee601b73ef62afa1dbd59d08868e8dc1a6307d0
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A get accessor must be at least as accessible as the setter [test-class-definiton6.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-class-definiton6.ts b/es2panda/test/parser/ts/test-class-definiton6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..13e493e87f96f37842f13aa598e8bc1199df3338
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton6.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    private get 5() { return }
+    set 5(k) { }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton7-expected.txt b/es2panda/test/parser/ts/test-class-definiton7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..175fbd40c47a0fd82f62ceb5e0e44b67989d0a88
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected modifier on private identifier [test-class-definiton7.ts:2:12]
diff --git a/es2panda/test/parser/ts/test-class-definiton7.ts b/es2panda/test/parser/ts/test-class-definiton7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..741dd3bac8512f9eeca87e74c6c618ab92729787
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    static #a;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton8-expected.txt b/es2panda/test/parser/ts/test-class-definiton8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3024cb4dccb42a798349143d694fb797f8191f92
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton8-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected. [test-class-definiton8.ts:2:9]
diff --git a/es2panda/test/parser/ts/test-class-definiton8.ts b/es2panda/test/parser/ts/test-class-definiton8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c60e2b4616d3d39e76da6af263ebc92cbe09a8ab
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare class Foo {
+    a() b()
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-definiton9-expected.txt b/es2panda/test/parser/ts/test-class-definiton9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1c2d06678cadd3ecafbdeaaf87c72af8e8420fd9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton9-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected. [test-class-definiton9.ts:2:7]
diff --git a/es2panda/test/parser/ts/test-class-definiton9.ts b/es2panda/test/parser/ts/test-class-definiton9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..00779a0a3c63e7c62813bf2a6dd992451a0f5caa
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-definiton9.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    a b;
+}
diff --git a/es2panda/test/parser/ts/test-class-method-overload-expected.txt b/es2panda/test/parser/ts/test-class-method-overload-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c2a73a78a9b6a6667461dfe4beff7ed11a4590f1
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload-expected.txt
@@ -0,0 +1,1938 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Class1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 15
+            },
+            "end": {
+              "line": 1,
+              "column": 21
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "Identifier",
+                "name": "constructor",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "constructor",
+              "static": false,
+              "optional": false,
+              "computed": false,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 19
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 19
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 19
+                }
+              }
+            },
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "Identifier",
+                "name": "constructor",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 16
+                  }
+                }
+              },
+              "kind": "constructor",
+              "static": false,
+              "optional": false,
+              "computed": false,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 18
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 28
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 28
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 28
+                }
+              }
+            }
+          ],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 6
+                },
+                "end": {
+                  "line": 4,
+                  "column": 9
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 9
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 5
+                },
+                "end": {
+                  "line": 5,
+                  "column": 6
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 6
+                },
+                "end": {
+                  "line": 5,
+                  "column": 9
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 9
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 9
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 6
+                },
+                "end": {
+                  "line": 6,
+                  "column": 9
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 9
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 22
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 9
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Class2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 7
+            },
+            "end": {
+              "line": 9,
+              "column": 13
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 1
+            },
+            "end": {
+              "line": 29,
+              "column": 2
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "s",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 5
+                },
+                "end": {
+                  "line": 10,
+                  "column": 6
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "n",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 5
+                },
+                "end": {
+                  "line": 11,
+                  "column": 6
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 5
+                },
+                "end": {
+                  "line": 16,
+                  "column": 6
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "s",
+                    "typeAnnotation": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "optional": true,
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 7
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 8
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "n",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "optional": true,
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 20
+                      }
+                    }
+                  }
+                ],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ExpressionStatement",
+                      "expression": {
+                        "type": "AssignmentExpression",
+                        "operator": "=",
+                        "left": {
+                          "type": "MemberExpression",
+                          "object": {
+                            "type": "ThisExpression",
+                            "loc": {
+                              "start": {
+                                "line": 17,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 17,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "property": {
+                            "type": "Identifier",
+                            "name": "s",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 17,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 17,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "computed": false,
+                          "optional": false,
+                          "loc": {
+                            "start": {
+                              "line": 17,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 17,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "LogicalExpression",
+                          "operator": "||",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "s",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 17,
+                                "column": 18
+                              },
+                              "end": {
+                                "line": 17,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "StringLiteral",
+                            "value": "",
+                            "loc": {
+                              "start": {
+                                "line": 17,
+                                "column": 23
+                              },
+                              "end": {
+                                "line": 17,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 17,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 17,
+                              "column": 25
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 26
+                        }
+                      }
+                    },
+                    {
+                      "type": "ExpressionStatement",
+                      "expression": {
+                        "type": "AssignmentExpression",
+                        "operator": "=",
+                        "left": {
+                          "type": "MemberExpression",
+                          "object": {
+                            "type": "ThisExpression",
+                            "loc": {
+                              "start": {
+                                "line": 18,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 18,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "property": {
+                            "type": "Identifier",
+                            "name": "n",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 18,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 18,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "computed": false,
+                          "optional": false,
+                          "loc": {
+                            "start": {
+                              "line": 18,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 18,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "right": {
+                          "type": "LogicalExpression",
+                          "operator": "||",
+                          "left": {
+                            "type": "Identifier",
+                            "name": "n",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 18,
+                                "column": 18
+                              },
+                              "end": {
+                                "line": 18,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "right": {
+                            "type": "NumberLiteral",
+                            "value": 0,
+                            "loc": {
+                              "start": {
+                                "line": 18,
+                                "column": 23
+                              },
+                              "end": {
+                                "line": 18,
+                                "column": 24
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 18,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 18,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 18,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 18,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 18,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 18,
+                          "column": 25
+                        }
+                      }
+                    },
+                    {
+                      "type": "ExpressionStatement",
+                      "expression": {
+                        "type": "CallExpression",
+                        "callee": {
+                          "type": "MemberExpression",
+                          "object": {
+                            "type": "ThisExpression",
+                            "loc": {
+                              "start": {
+                                "line": 19,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 19,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "property": {
+                            "type": "Identifier",
+                            "name": "f",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 19,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 19,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "computed": false,
+                          "optional": false,
+                          "loc": {
+                            "start": {
+                              "line": 19,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 19,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "arguments": [],
+                        "optional": false,
+                        "loc": {
+                          "start": {
+                            "line": 19,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 19,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 19,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 19,
+                          "column": 18
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 6
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 6
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 6
+                },
+                "end": {
+                  "line": 20,
+                  "column": 6
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 6
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 9
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 9
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "s",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 13,
+                              "column": 13
+                            },
+                            "end": {
+                              "line": 13,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "optional": true,
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 10
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 21
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 21
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 14,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 14,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 11
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 6
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 9
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 9
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 6
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 5
+                },
+                "end": {
+                  "line": 25,
+                  "column": 6
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 12
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 12
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 6
+                },
+                "end": {
+                  "line": 25,
+                  "column": 12
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 21,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 11
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 6
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 9
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 22,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 22,
+                    "column": 9
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 6
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 9
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 9
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 8
+                    }
+                  }
+                },
+                "kind": "method",
+                "static": false,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 11
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 11
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 12
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "f",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 5
+                },
+                "end": {
+                  "line": 26,
+                  "column": 6
+                }
+              }
+            },
+            "kind": "method",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "TSVoidKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 14
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ExpressionStatement",
+                      "expression": {
+                        "type": "UpdateExpression",
+                        "operator": "++",
+                        "prefix": false,
+                        "argument": {
+                          "type": "MemberExpression",
+                          "object": {
+                            "type": "ThisExpression",
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "property": {
+                            "type": "Identifier",
+                            "name": "n",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "computed": false,
+                          "optional": false,
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 15
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 18
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 6
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 6
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 6
+                },
+                "end": {
+                  "line": 28,
+                  "column": 6
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 6
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 14
+          },
+          "end": {
+            "line": 29,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 29,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-class-method-overload.ts b/es2panda/test/parser/ts/test-class-method-overload.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ce37508274d75d46be85c90bc218ab98031a1e2c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload.ts
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare class Class1 {
+    constructor();
+    constructor(a: number);
+    a();
+    a();
+    b();
+}
+
+class Class2 {
+    s: string;
+    n: number;
+    a();
+    "a"(s?: string);
+    "a"();
+    a();
+    a(s?: string, n?: number) {
+        this.s = s || "";
+        this.n = n || 0;
+        this.f();
+    };
+    "1"();
+    1();
+    1();
+    "1"();
+    1() { };
+    f(): void {
+        this.n++;
+    };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload1-expected.txt b/es2panda/test/parser/ts/test-class-method-overload1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..366aa66c3b349a8b09dac7a1c1ae28302be65bf2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation is missing or not immediately following the declaration. [test-class-method-overload1.ts:2:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload1.ts b/es2panda/test/parser/ts/test-class-method-overload1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..248f22cb698230754360843edea14a2ef544c1f6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload1.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar();
+    baz: string;
+    bar() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload10-expected.txt b/es2panda/test/parser/ts/test-class-method-overload10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..19e5bfedb56cfa256c95719ea82173e5f78d85e1
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload10-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation name must be 'bar'. [test-class-method-overload10.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload10.ts b/es2panda/test/parser/ts/test-class-method-overload10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5070ab1cdef8644adb1ee77ab5596f3e9586d291
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload10.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    "bar"();
+    baz() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload11-expected.txt b/es2panda/test/parser/ts/test-class-method-overload11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..77e274b0757e959aa1fa8e7bbfa5052cfa2fd67c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload11-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation name must be 'bar'. [test-class-method-overload11.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload11.ts b/es2panda/test/parser/ts/test-class-method-overload11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..804ebf9b56c646eba4da994e4b183d00ed29f617
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload11.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    "bar"();
+    1() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload12-expected.txt b/es2panda/test/parser/ts/test-class-method-overload12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..13c09418b30589783774d10b86536f6246d2dac2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload12-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation name must be '1'. [test-class-method-overload12.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload12.ts b/es2panda/test/parser/ts/test-class-method-overload12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..649138163ab46dc0aaa1b7b131d31735a6cd05a2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload12.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    1();
+    "2"() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload13-expected.txt b/es2panda/test/parser/ts/test-class-method-overload13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..840ac021a1492639929524347ff6993815ad4737
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload13-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation name must be '1'. [test-class-method-overload13.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload13.ts b/es2panda/test/parser/ts/test-class-method-overload13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..123a7754256977d4b3fe341e77cc00332f6c9ea8
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload13.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    1();
+    2() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload2-expected.txt b/es2panda/test/parser/ts/test-class-method-overload2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2588406317ed997da65481c7789464adc0b2fa68
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation is missing or not immediately following the declaration. [test-class-method-overload2.ts:5:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload2.ts b/es2panda/test/parser/ts/test-class-method-overload2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b3489d4e12ae317147b3d0bc395170f1e1cf3be7
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload2.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar();
+    bar() { };
+    baz: string;
+    bar();
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload3-expected.txt b/es2panda/test/parser/ts/test-class-method-overload3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cbfdde3fd40fb1bd3bfe9ecdd4d2f6374e8d4cdf
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Overload signatures must all be optional or required. [test-class-method-overload3.ts:2:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload3.ts b/es2panda/test/parser/ts/test-class-method-overload3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4d93c5d058235c4b01ce377cf8f603130289e2ec
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload3.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar();
+    bar();
+    bar?() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload4-expected.txt b/es2panda/test/parser/ts/test-class-method-overload4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f21dfe5e2c3f0a4f4dfde0bea6508229f6d144b4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation is missing or not immediately following the declaration. [test-class-method-overload4.ts:2:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload4.ts b/es2panda/test/parser/ts/test-class-method-overload4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb59c8fbb616b70d592dc79b0c701c685bca8402
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar();
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload5-expected.txt b/es2panda/test/parser/ts/test-class-method-overload5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65146bd02af2036ba4b4b092bde4afda728183f4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Duplicate function implementation. [test-class-method-overload5.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload5.ts b/es2panda/test/parser/ts/test-class-method-overload5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..230546d16402b19019e488fa10034fd31ba9af22
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload5.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar() { };
+    bar() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload6-expected.txt b/es2panda/test/parser/ts/test-class-method-overload6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bfd9aef8aeba7700533b2aade6e5f2a21661e989
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Duplicate function implementation. [test-class-method-overload6.ts:4:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload6.ts b/es2panda/test/parser/ts/test-class-method-overload6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b9caa430fdf500f14f27181ca0cc29006eb05396
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload6.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar() { };
+    baz() { };
+    bar() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload7-expected.txt b/es2panda/test/parser/ts/test-class-method-overload7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..415ab886958d33a9044ca0dae26db8ca8d037236
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation name must be 'bar'. [test-class-method-overload7.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload7.ts b/es2panda/test/parser/ts/test-class-method-overload7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e0d6b9f258c91dd77cbac7998a2c7e718d768f77
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload7.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar();
+    baz() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload8-expected.txt b/es2panda/test/parser/ts/test-class-method-overload8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e283498fe5fa0f43ab1f65c299684fd1cf37b03
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload8-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation name must be 'bar'. [test-class-method-overload8.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload8.ts b/es2panda/test/parser/ts/test-class-method-overload8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..173d094cdc9d039a4b9a8ea417c127262cc573a9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload8.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    bar();
+    "baz"() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-class-method-overload9-expected.txt b/es2panda/test/parser/ts/test-class-method-overload9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ab32ea0a351263c4bd6c1057150a1b760f8146d4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload9-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Function implementation name must be 'bar'. [test-class-method-overload9.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-class-method-overload9.ts b/es2panda/test/parser/ts/test-class-method-overload9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..796886524a419aa0954392357d08ef85400fa65b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-class-method-overload9.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    "bar"();
+    "baz"() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-enum-declaration-expected.txt b/es2panda/test/parser/ts/test-enum-declaration-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..869d46b393273b13180198904a755cb848bb8737
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration-expected.txt
@@ -0,0 +1,358 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSEnumDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 9
+          }
+        }
+      },
+      "members": [
+        {
+          "type": "TSEnumMember",
+          "id": {
+            "type": "Identifier",
+            "name": "A",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 6
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          }
+        },
+        {
+          "type": "TSEnumMember",
+          "id": {
+            "type": "Identifier",
+            "name": "B",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "initializer": {
+            "type": "BinaryExpression",
+            "operator": "<<",
+            "left": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 4,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 14
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 9
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 9
+            },
+            "end": {
+              "line": 3,
+              "column": 16
+            }
+          }
+        },
+        {
+          "type": "TSEnumMember",
+          "id": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 6
+            },
+            "end": {
+              "line": 4,
+              "column": 7
+            }
+          }
+        },
+        {
+          "type": "TSEnumMember",
+          "id": {
+            "type": "Identifier",
+            "name": "D",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "initializer": {
+            "type": "BinaryExpression",
+            "operator": "|",
+            "left": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 9
+                },
+                "end": {
+                  "line": 5,
+                  "column": 10
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 13
+                },
+                "end": {
+                  "line": 5,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 9
+              },
+              "end": {
+                "line": 5,
+                "column": 14
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 9
+            },
+            "end": {
+              "line": 5,
+              "column": 15
+            }
+          }
+        },
+        {
+          "type": "TSEnumMember",
+          "id": {
+            "type": "Identifier",
+            "name": "E",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "initializer": {
+            "type": "NumberLiteral",
+            "value": 6,
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 9
+              },
+              "end": {
+                "line": 6,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 9
+            },
+            "end": {
+              "line": 6,
+              "column": 11
+            }
+          }
+        },
+        {
+          "type": "TSEnumMember",
+          "id": {
+            "type": "Identifier",
+            "name": "F",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "initializer": {
+            "type": "MemberExpression",
+            "object": {
+              "type": "StringLiteral",
+              "value": "123",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 9
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "length",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 15
+                },
+                "end": {
+                  "line": 7,
+                  "column": 21
+                }
+              }
+            },
+            "computed": false,
+            "optional": false,
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 9
+              },
+              "end": {
+                "line": 7,
+                "column": 21
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 9
+            },
+            "end": {
+              "line": 7,
+              "column": 22
+            }
+          }
+        }
+      ],
+      "const": false,
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-enum-declaration.ts b/es2panda/test/parser/ts/test-enum-declaration.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e6d3b6a5bb434af04a5b74543723850aaa678ca5
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+enum Foo {
+    A,
+    B = 5 << 4,
+    C,
+    D = B | C,
+    E = 6,
+    F = "123".length,
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-enum-declaration1-expected.txt b/es2panda/test/parser/ts/test-enum-declaration1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e5ccc58059079210b2ad5a8bc09bea870126b5a9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Variable 'a' has already been declared. [test-enum-declaration1.ts:3:5]
diff --git a/es2panda/test/parser/ts/test-enum-declaration1.ts b/es2panda/test/parser/ts/test-enum-declaration1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..279e7d12d3e30d4983b04a98eecfb29c48741b4c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration1.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+enum foo {
+    a,
+    a = "bar",
+}
diff --git a/es2panda/test/parser/ts/test-enum-declaration2-expected.txt b/es2panda/test/parser/ts/test-enum-declaration2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dea9b8365041cdc4b867d24cc30d43c36b528258
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token in enum member [test-enum-declaration2.ts:2:5]
diff --git a/es2panda/test/parser/ts/test-enum-declaration2.ts b/es2panda/test/parser/ts/test-enum-declaration2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3d269306d3ddfc29b51fa802bb08fcc8a55ddfea
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration2.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+enum Foo {
+    5 = 2,
+    B = "foo",
+}
diff --git a/es2panda/test/parser/ts/test-enum-declaration3-expected.txt b/es2panda/test/parser/ts/test-enum-declaration3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f6847b86bfdffe733dc99bf992c8c73b336b5210
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token in enum member [test-enum-declaration3.ts:2:12]
diff --git a/es2panda/test/parser/ts/test-enum-declaration3.ts b/es2panda/test/parser/ts/test-enum-declaration3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b01c86137bfb32f90407d51a63ac345b30c0bd6d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+const enum Foo {
+    G = 1, 2, 3
+}
diff --git a/es2panda/test/parser/ts/test-enum-declaration4-expected.txt b/es2panda/test/parser/ts/test-enum-declaration4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..92b3177c9a512f4f787b9d99540537a340a587fb
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Enum declarations can only merge with namespace or other enum declarations. [test-enum-declaration4.ts:4:10]
diff --git a/es2panda/test/parser/ts/test-enum-declaration4.ts b/es2panda/test/parser/ts/test-enum-declaration4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b28fe68fad7de60cbadd4d166076fc6e70b9328
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration4.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+const enum Foo {
+}
+
+enum Foo {}
diff --git a/es2panda/test/parser/ts/test-enum-declaration5-expected.txt b/es2panda/test/parser/ts/test-enum-declaration5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4d6db83c5aa9b73c39e5f1697e9d86f92a267a9c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Enum declarations can only merge with namespace or other enum declarations. [test-enum-declaration5.ts:3:16]
diff --git a/es2panda/test/parser/ts/test-enum-declaration5.ts b/es2panda/test/parser/ts/test-enum-declaration5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..43d8a7d1807c0b2c4eac300c11a25c44b8cdad77
--- /dev/null
+++ b/es2panda/test/parser/ts/test-enum-declaration5.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+enum Foo {}
+
+const enum Foo {
+}
+
diff --git a/es2panda/test/parser/ts/test-func-decl1-expected.txt b/es2panda/test/parser/ts/test-func-decl1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..48d47649c9e7aa81d8e51c89b602c9459f2c5b6a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-decl1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Private identifiers are not allowed outside class bodies. [test-func-decl1.ts:2:10]
diff --git a/es2panda/test/parser/ts/test-func-decl1.ts b/es2panda/test/parser/ts/test-func-decl1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e2848e475789de09dc12c65c8f20ebc3909dccfe
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-decl1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo() {
+    this.#bar = "baz";
+}
diff --git a/es2panda/test/parser/ts/test-func-param-expected.txt b/es2panda/test/parser/ts/test-func-param-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..83355a26e0a86f28d92b7eb2c2019eebaf08a918
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param-expected.txt
@@ -0,0 +1,2314 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 19
+                },
+                "end": {
+                  "line": 1,
+                  "column": 25
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 16
+              },
+              "end": {
+                "line": 1,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 30
+                },
+                "end": {
+                  "line": 1,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 27
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 38
+            },
+            "end": {
+              "line": 1,
+              "column": 41
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 41
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 41
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "typeAnnotation": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 26
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 16
+                },
+                "end": {
+                  "line": 2,
+                  "column": 17
+                }
+              }
+            },
+            "right": {
+              "type": "BooleanLiteral",
+              "value": true,
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 29
+                },
+                "end": {
+                  "line": 2,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 16
+              },
+              "end": {
+                "line": 2,
+                "column": 33
+              }
+            }
+          },
+          {
+            "type": "RestElement",
+            "argument": {
+              "type": "Identifier",
+              "name": "b",
+              "typeAnnotation": {
+                "type": "TSArrayType",
+                "elementType": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 47
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 49
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 38
+                },
+                "end": {
+                  "line": 2,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 35
+              },
+              "end": {
+                "line": 2,
+                "column": 39
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 51
+            },
+            "end": {
+              "line": 2,
+              "column": 54
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 54
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 54
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 16
+                },
+                "end": {
+                  "line": 3,
+                  "column": 17
+                }
+              }
+            },
+            "right": {
+              "type": "NumberLiteral",
+              "value": 6,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 20
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 16
+              },
+              "end": {
+                "line": 3,
+                "column": 21
+              }
+            }
+          },
+          {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 25
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "d",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 28
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 23
+              },
+              "end": {
+                "line": 3,
+                "column": 29
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 31
+              },
+              "end": {
+                "line": 3,
+                "column": 32
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 35
+            },
+            "end": {
+              "line": 3,
+              "column": 38
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 38
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 10
+            },
+            "end": {
+              "line": 4,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ObjectPattern",
+            "properties": [],
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 21
+                },
+                "end": {
+                  "line": 4,
+                  "column": 27
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 16
+              },
+              "end": {
+                "line": 4,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 31
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 34
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 43
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 37
+                },
+                "end": {
+                  "line": 4,
+                  "column": 45
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 29
+              },
+              "end": {
+                "line": 4,
+                "column": 35
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 47
+            },
+            "end": {
+              "line": 4,
+              "column": 50
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 50
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func5",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 10
+            },
+            "end": {
+              "line": 5,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ArrayPattern",
+              "elements": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "typeAnnotation": {
+                "type": "TSTupleType",
+                "elementTypes": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 32
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 40
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 40
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 16
+                },
+                "end": {
+                  "line": 5,
+                  "column": 22
+                }
+              }
+            },
+            "right": {
+              "type": "ArrayExpression",
+              "elements": [
+                {
+                  "type": "NumberLiteral",
+                  "value": 1,
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 45
+                    }
+                  }
+                },
+                {
+                  "type": "StringLiteral",
+                  "value": "foo",
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 52
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 43
+                },
+                "end": {
+                  "line": 5,
+                  "column": 53
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 16
+              },
+              "end": {
+                "line": 5,
+                "column": 53
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 55
+            },
+            "end": {
+              "line": 5,
+              "column": 58
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 58
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 58
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 10
+            },
+            "end": {
+              "line": 6,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "AssignmentPattern",
+            "left": {
+              "type": "ObjectPattern",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": true,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 22
+                    }
+                  }
+                }
+              ],
+              "typeAnnotation": {
+                "type": "TSTypeLiteral",
+                "members": [
+                  {
+                    "type": "TSPropertySignature",
+                    "computed": false,
+                    "optional": false,
+                    "readonly": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 37
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 38
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSPropertySignature",
+                    "computed": false,
+                    "optional": false,
+                    "readonly": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 6,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 6,
+                          "column": 48
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 50
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 50
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 16
+                },
+                "end": {
+                  "line": 6,
+                  "column": 24
+                }
+              }
+            },
+            "right": {
+              "type": "ObjectExpression",
+              "properties": [
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 55
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 56
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 0,
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 58
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 59
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 59
+                    }
+                  }
+                },
+                {
+                  "type": "Property",
+                  "method": false,
+                  "shorthand": false,
+                  "computed": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 61
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 62
+                      }
+                    }
+                  },
+                  "value": {
+                    "type": "NumberLiteral",
+                    "value": 0,
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 64
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 65
+                      }
+                    }
+                  },
+                  "kind": "init",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 61
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 65
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 53
+                },
+                "end": {
+                  "line": 6,
+                  "column": 67
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 16
+              },
+              "end": {
+                "line": 6,
+                "column": 67
+              }
+            }
+          }
+        ],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 69
+            },
+            "end": {
+              "line": 6,
+              "column": 72
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 72
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 72
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 18
+            },
+            "end": {
+              "line": 7,
+              "column": 23
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 26
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 29
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 40
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 48
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 32
+                },
+                "end": {
+                  "line": 7,
+                  "column": 48
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 24
+              },
+              "end": {
+                "line": 7,
+                "column": 30
+              }
+            }
+          }
+        ],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 9
+          },
+          "end": {
+            "line": 8,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 9
+        },
+        "end": {
+          "line": 8,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func8",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 18
+            },
+            "end": {
+              "line": 8,
+              "column": 23
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 27
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 27
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 27
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 30
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 30
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 30
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 45
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 36
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 48
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 50
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 56
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 58
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 34
+                },
+                "end": {
+                  "line": 8,
+                  "column": 58
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 24
+              },
+              "end": {
+                "line": 8,
+                "column": 32
+              }
+            }
+          }
+        ],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 9
+          },
+          "end": {
+            "line": 9,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 9
+        },
+        "end": {
+          "line": 9,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func9",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 18
+            },
+            "end": {
+              "line": 9,
+              "column": 23
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ArrayPattern",
+            "elements": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 26
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 29
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 49
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 33
+                },
+                "end": {
+                  "line": 9,
+                  "column": 49
+                }
+              }
+            },
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 24
+              },
+              "end": {
+                "line": 9,
+                "column": 30
+              }
+            }
+          }
+        ],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 9
+          },
+          "end": {
+            "line": 10,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 9
+        },
+        "end": {
+          "line": 10,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func10",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 18
+            },
+            "end": {
+              "line": 10,
+              "column": 24
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "ObjectPattern",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 28
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 28
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 28
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": true,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 31
+                    }
+                  }
+                },
+                "value": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 31
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 31
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 48
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 49
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 52
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 58
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 60
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 36
+                },
+                "end": {
+                  "line": 10,
+                  "column": 60
+                }
+              }
+            },
+            "optional": true,
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 25
+              },
+              "end": {
+                "line": 10,
+                "column": 33
+              }
+            }
+          }
+        ],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 9
+          },
+          "end": {
+            "line": 12,
+            "column": 10
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 9
+        },
+        "end": {
+          "line": 12,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 7
+                  }
+                }
+              },
+              {
+                "type": "ObjectPattern",
+                "properties": [
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 20
+                      }
+                    }
+                  },
+                  {
+                    "type": "Property",
+                    "method": false,
+                    "shorthand": true,
+                    "computed": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 23
+                        }
+                      }
+                    },
+                    "value": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 23
+                        }
+                      }
+                    },
+                    "kind": "init",
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 23
+                      }
+                    }
+                  }
+                ],
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": true,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 10
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 21
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": true,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "c",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 15,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 15,
+                            "column": 10
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 15,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 15,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 15,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 15,
+                          "column": 17
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 6
+                    }
+                  }
+                },
+                "optional": true,
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 25
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 9
+                },
+                "end": {
+                  "line": 16,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 16,
+                "column": 16
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 22
+          },
+          "end": {
+            "line": 17,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 11
+          },
+          "end": {
+            "line": 12,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 17,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-func-param.ts b/es2panda/test/parser/ts/test-func-param.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bc13c5129d86d69cf726cf6c3755a8b45f56f4cf
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param.ts
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func1(a: number, b: string) { }
+function func2(a: boolean = true, ...b: number[]) { }
+function func3(a = 6, [c, d], b?) { }
+function func4({ }: number, [a, b]: string[]) { }
+function func5([a, b]: [number, string] = [1, "foo"]) { }
+function func6({ a, b }: { a: number, b: number } = { a: 0, b: 0 }) { }
+declare function func7([a, b]: [number, string])
+declare function func8({ a, b }: { a: number, b: number })
+declare function func9([a, b]?: [number, string])
+declare function func10({ a, b }?: { a: number, b: number })
+
+interface Interface1 {
+    (a: number, { b, c }?: {
+        b?: boolean;
+        c?: any;
+    }): string;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param1-expected.txt b/es2panda/test/parser/ts/test-func-param1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d4f99f634c1151dbf68a3481480dc14637067ddf
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A required parameter cannot follow an optional parameter [test-func-param1.ts:1:22]
diff --git a/es2panda/test/parser/ts/test-func-param1.ts b/es2panda/test/parser/ts/test-func-param1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..be7d57a665c133d07fcd9d7010ace969b1cc8a40
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a, b?, c) {
+
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param2-expected.txt b/es2panda/test/parser/ts/test-func-param2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b47543d6819af7de6b36099230bfcb27be17f955
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A 'this' parameter must be the first parameter [test-func-param2.ts:1:21]
diff --git a/es2panda/test/parser/ts/test-func-param2.ts b/es2panda/test/parser/ts/test-func-param2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a1b2eaf082e2e7af71c4cbe7904f84cc2147e178
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a, this) {
+
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param3-expected.txt b/es2panda/test/parser/ts/test-func-param3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8154cbc74bfcd79293df2c5188d4db0eb10b3d24
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A constructor cannot have a 'this' parameter [test-func-param3.ts:2:21]
diff --git a/es2panda/test/parser/ts/test-func-param3.ts b/es2panda/test/parser/ts/test-func-param3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c07c1ae0976e197c601d6e7ff29b609c65f947ed
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+    constructor(this) { }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param4-expected.txt b/es2panda/test/parser/ts/test-func-param4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3745244a85f614c5d680b4024bf90168b868cf41
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'get' and 'set' accessors cannot declare 'this' parameters [test-func-param4.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-func-param4.ts b/es2panda/test/parser/ts/test-func-param4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ce5d745090d6e68f16ac7e285cf4d91ebea96789
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+    get foo(this) { return; }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param5-expected.txt b/es2panda/test/parser/ts/test-func-param5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3fc4bd7736b16f580938dfa76547d9e3757d84d8
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'constructor' cannot be used as a parameter property name [test-func-param5.ts:2:28]
diff --git a/es2panda/test/parser/ts/test-func-param5.ts b/es2panda/test/parser/ts/test-func-param5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a6dc7e44c2bb853a75a1d662ed8c1c313cc0d1df
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+    constructor(constructor) { }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param6-expected.txt b/es2panda/test/parser/ts/test-func-param6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bb805a334d0f816b31adfaa01e9b17e6909d7899
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A binding pattern parameter cannot be optional in an implementation signature [test-func-param6.ts:1:16]
diff --git a/es2panda/test/parser/ts/test-func-param6.ts b/es2panda/test/parser/ts/test-func-param6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c1f00939e25a6a0b85da0e7e3d557d04213e2a9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo([]?) { }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param7-expected.txt b/es2panda/test/parser/ts/test-func-param7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d814bf5976b8784f920cdd0b7fd96a1182eac7f
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A rest parameter cannot be optional [test-func-param7.ts:1:18]
diff --git a/es2panda/test/parser/ts/test-func-param7.ts b/es2panda/test/parser/ts/test-func-param7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..14852d8aebd432b851649a698141fb74de2c9007
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(...a?) { }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-func-param8-expected.txt b/es2panda/test/parser/ts/test-func-param8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a5bf39e304d3cf04fa787b8a60e6358b6b9ffe3e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param8-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Parameter cannot have question mark and initializer [test-func-param8.ts:1:16]
diff --git a/es2panda/test/parser/ts/test-func-param8.ts b/es2panda/test/parser/ts/test-func-param8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e0b5280302839dc500c536972d5c5eeaa41abc98
--- /dev/null
+++ b/es2panda/test/parser/ts/test-func-param8.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a?= 5) { }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-function-overload-expected.txt b/es2panda/test/parser/ts/test-function-overload-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d8375d7314a4071e7b5525d89f3623763f2e91f
--- /dev/null
+++ b/es2panda/test/parser/ts/test-function-overload-expected.txt
@@ -0,0 +1,464 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 17
+                },
+                "end": {
+                  "line": 1,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 14
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 28
+                },
+                "end": {
+                  "line": 1,
+                  "column": 34
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 25
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 37
+            },
+            "end": {
+              "line": 1,
+              "column": 44
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 45
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 17
+                },
+                "end": {
+                  "line": 2,
+                  "column": 23
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 14
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 29
+                },
+                "end": {
+                  "line": 2,
+                  "column": 35
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 25
+              },
+              "end": {
+                "line": 2,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 38
+            },
+            "end": {
+              "line": 2,
+              "column": 45
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 46
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 46
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 24
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 14
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 30
+                },
+                "end": {
+                  "line": 3,
+                  "column": 36
+                }
+              }
+            },
+            "optional": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 26
+              },
+              "end": {
+                "line": 3,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 39
+            },
+            "end": {
+              "line": 3,
+              "column": 46
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 47
+            },
+            "end": {
+              "line": 5,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "bar",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 10
+            },
+            "end": {
+              "line": 7,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 16
+            },
+            "end": {
+              "line": 7,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 7,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 19
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-function-overload.ts b/es2panda/test/parser/ts/test-function-overload.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6de3f1be06106f078398a68fcd86c8daabed8702
--- /dev/null
+++ b/es2panda/test/parser/ts/test-function-overload.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(a: number, b: string): boolean;
+function foo(a: number, b?: string): boolean;
+function foo(a?: number, b?: string): boolean {
+    return true;
+}
+
+function bar() { }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-function-overload1-expected.txt b/es2panda/test/parser/ts/test-function-overload1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a51369d3c0ceebe44abf1af46654a200434e2561
--- /dev/null
+++ b/es2panda/test/parser/ts/test-function-overload1-expected.txt
@@ -0,0 +1,150 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 16
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 16
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-function-overload1.ts b/es2panda/test/parser/ts/test-function-overload1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2923655b0c5f6201167d397fef7e8581751638fd
--- /dev/null
+++ b/es2panda/test/parser/ts/test-function-overload1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo();
+function foo();
+function foo();
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-function-overload2-expected.txt b/es2panda/test/parser/ts/test-function-overload2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..55199d46325a0fcc0f3479cbf7973e36a9c69e0b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-function-overload2-expected.txt
@@ -0,0 +1,164 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "bar",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "bar",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "foo",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 13
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 16
+            },
+            "end": {
+              "line": 3,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 19
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 19
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-function-overload2.ts b/es2panda/test/parser/ts/test-function-overload2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..85f0070e4305bb4e8a1139863c6df76f197f647a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-function-overload2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function bar();
+function bar();
+function foo() { }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-if-expected.txt b/es2panda/test/parser/ts/test-if-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..879c5e75d6d788c418df8c2e621cd14e52626b5b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-if-expected.txt
@@ -0,0 +1,159 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "IfStatement",
+      "test": {
+        "type": "NumberLiteral",
+        "value": 1,
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 5
+          },
+          "end": {
+            "line": 1,
+            "column": 6
+          }
+        }
+      },
+      "consequent": {
+        "type": "TSEnumDeclaration",
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 16
+            },
+            "end": {
+              "line": 2,
+              "column": 17
+            }
+          }
+        },
+        "members": [],
+        "const": true,
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 11
+          },
+          "end": {
+            "line": 2,
+            "column": 21
+          }
+        }
+      },
+      "alternate": {
+        "type": "IfStatement",
+        "test": {
+          "type": "NumberLiteral",
+          "value": 2,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "consequent": {
+          "type": "TSEnumDeclaration",
+          "id": {
+            "type": "Identifier",
+            "name": "B",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 16
+              },
+              "end": {
+                "line": 4,
+                "column": 17
+              }
+            }
+          },
+          "members": [],
+          "const": true,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 11
+            },
+            "end": {
+              "line": 4,
+              "column": 21
+            }
+          }
+        },
+        "alternate": {
+          "type": "TSEnumDeclaration",
+          "id": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 16
+              },
+              "end": {
+                "line": 6,
+                "column": 17
+              }
+            }
+          },
+          "members": [],
+          "const": true,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 11
+            },
+            "end": {
+              "line": 6,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 6
+          },
+          "end": {
+            "line": 6,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 21
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-if.ts b/es2panda/test/parser/ts/test-if.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df1aa01a5ed4edbc24949a3cb144e3d088b9558e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-if.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+if (1)
+    const enum A { }
+else if (2)
+    const enum B { }
+else
+    const enum C { }
diff --git a/es2panda/test/parser/ts/test-interface-expected.txt b/es2panda/test/parser/ts/test-interface-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6de8367b36eb6227035eeb38a34777c2ab6471be
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface-expected.txt
@@ -0,0 +1,795 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": true,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 16
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 5
+                },
+                "end": {
+                  "line": 3,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSMethodSignature",
+            "computed": false,
+            "optional": false,
+            "key": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSFunctionType",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 12
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSVoidKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 23
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 40
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 8
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 54
+                    }
+                  }
+                },
+                "optional": true,
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 43
+                  }
+                }
+              }
+            ],
+            "typeAnnotation": {
+              "type": "TSUndefinedKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 57
+                },
+                "end": {
+                  "line": 4,
+                  "column": 66
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 67
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 18
+                },
+                "end": {
+                  "line": 5,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 15
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 18
+                },
+                "end": {
+                  "line": 6,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSConstructSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSNullKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 16
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 10
+                  }
+                }
+              },
+              {
+                "type": "Identifier",
+                "name": "b",
+                "typeAnnotation": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 28
+                    }
+                  }
+                },
+                "optional": true,
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 43
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 44
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 45
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 53
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 54
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 55
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 56
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 59
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 60
+                            }
+                          }
+                        },
+                        {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 7,
+                              "column": 62
+                            },
+                            "end": {
+                              "line": 7,
+                              "column": 63
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 58
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 64
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 73
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 75
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 31
+                },
+                "end": {
+                  "line": 7,
+                  "column": 75
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 27
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "TSQualifiedName",
+            "left": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 23
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            "right": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 25
+                },
+                "end": {
+                  "line": 1,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 23
+              },
+              "end": {
+                "line": 1,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 27
+            },
+            "end": {
+              "line": 1,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 8,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-interface.ts b/es2panda/test/parser/ts/test-interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1072c19fd2286976ffa52f562eecc23f9629a416
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface.ts
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface foo extends a.b {
+    a?: number,
+    b: string | boolean;
+    c(a: (a: number, b: void) => string, b?: number[]): undefined;
+    (a: string): string,
+    (a: number): number,
+    new(a: null, b?: string): { a: number, b: string, c?([a, b]): string }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-interface1-expected.txt b/es2panda/test/parser/ts/test-interface1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3caa47169ab4848515702894aa1110e8979e3e6b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Interface name cannot be 'boolean' [test-interface1.ts:1:11]
diff --git a/es2panda/test/parser/ts/test-interface1.ts b/es2panda/test/parser/ts/test-interface1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..09f0b32a7d175dc58bbf19c6c929efccb0be1416
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface boolean {
+
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-interface2-expected.txt b/es2panda/test/parser/ts/test-interface2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e2c28ba2982f06dfee9d9448d2aae5ca4e74cbab
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Identifier expected [test-interface2.ts:1:11]
diff --git a/es2panda/test/parser/ts/test-interface2.ts b/es2panda/test/parser/ts/test-interface2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3b9d59fdb93f0ab01f862db9a18368e67f141c45
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface 5 { }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-interface3-expected.txt b/es2panda/test/parser/ts/test-interface3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..970b9173339da53f0c0cc72ed2364e9a2438a9bf
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Identifier expected [test-interface3.ts:1:23]
diff --git a/es2panda/test/parser/ts/test-interface3.ts b/es2panda/test/parser/ts/test-interface3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e56398657f366e64f6bbe92d33aa84b88635d325
--- /dev/null
+++ b/es2panda/test/parser/ts/test-interface3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface foo extends 5 {
+
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-intersection-expected.txt b/es2panda/test/parser/ts/test-intersection-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..036ecb44e0dce69aa39e3e562760b09b257c884e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection-expected.txt
@@ -0,0 +1,1824 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSStringKeyword",
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 10
+          },
+          "end": {
+            "line": 1,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 16
+        },
+        "end": {
+          "line": 1,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 6
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSStringKeyword",
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 10
+          },
+          "end": {
+            "line": 2,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 16
+        },
+        "end": {
+          "line": 2,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 6
+          },
+          "end": {
+            "line": 3,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSStringKeyword",
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 10
+          },
+          "end": {
+            "line": 3,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 16
+        },
+        "end": {
+          "line": 3,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "D",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 6
+          },
+          "end": {
+            "line": 4,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSStringKeyword",
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 10
+          },
+          "end": {
+            "line": 4,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 16
+        },
+        "end": {
+          "line": 4,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "E",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 6
+          },
+          "end": {
+            "line": 5,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSStringKeyword",
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 10
+          },
+          "end": {
+            "line": 5,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 16
+        },
+        "end": {
+          "line": 5,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "F",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 6
+          },
+          "end": {
+            "line": 6,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSStringKeyword",
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 10
+          },
+          "end": {
+            "line": 6,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 16
+        },
+        "end": {
+          "line": 6,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 6
+          },
+          "end": {
+            "line": 8,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSIntersectionType",
+        "types": [
+          {
+            "type": "TSParenthesizedType",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "A",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSIntersectionType",
+                  "types": [
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "B",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 22
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 22
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 15
+                },
+                "end": {
+                  "line": 8,
+                  "column": 22
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 14
+              },
+              "end": {
+                "line": 8,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "TSParenthesizedType",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSIntersectionType",
+                  "types": [
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "C",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 29
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "D",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 34
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 27
+                },
+                "end": {
+                  "line": 8,
+                  "column": 34
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 26
+              },
+              "end": {
+                "line": 8,
+                "column": 35
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 14
+          },
+          "end": {
+            "line": 8,
+            "column": 35
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 35
+        },
+        "end": {
+          "line": 8,
+          "column": 36
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 6
+          },
+          "end": {
+            "line": 9,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSIntersectionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "A",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 15
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 15
+                  }
+                }
+              },
+              {
+                "type": "TSParenthesizedType",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "C",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 9,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 9,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 22
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "D",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 9,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 9,
+                            "column": 26
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 26
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 27
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 14
+              },
+              "end": {
+                "line": 9,
+                "column": 27
+              }
+            }
+          },
+          {
+            "type": "TSIntersectionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "B",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 31
+                  }
+                }
+              },
+              {
+                "type": "TSParenthesizedType",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "C",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 9,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 9,
+                            "column": 36
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 36
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "D",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 9,
+                            "column": 39
+                          },
+                          "end": {
+                            "line": 9,
+                            "column": 40
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 40
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 40
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 41
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 30
+              },
+              "end": {
+                "line": 9,
+                "column": 41
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 14
+          },
+          "end": {
+            "line": 9,
+            "column": 41
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 5
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 6
+          },
+          "end": {
+            "line": 10,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSIntersectionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "A",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 15
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 15
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "C",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 19
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 19
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 14
+              },
+              "end": {
+                "line": 10,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "TSIntersectionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "A",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 23
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 23
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "D",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 27
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 27
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 22
+              },
+              "end": {
+                "line": 10,
+                "column": 27
+              }
+            }
+          },
+          {
+            "type": "TSIntersectionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "B",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 31
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "C",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 35
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 35
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 30
+              },
+              "end": {
+                "line": 10,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "TSIntersectionType",
+            "types": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "B",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 39
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 39
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "D",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 43
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 43
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 38
+              },
+              "end": {
+                "line": 10,
+                "column": 43
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 14
+          },
+          "end": {
+            "line": 10,
+            "column": 43
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 43
+        },
+        "end": {
+          "line": 10,
+          "column": 44
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 6
+          },
+          "end": {
+            "line": 11,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSIntersectionType",
+        "types": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 14
+                },
+                "end": {
+                  "line": 11,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 14
+              },
+              "end": {
+                "line": 11,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSParenthesizedType",
+            "typeAnnotation": {
+              "type": "TSIntersectionType",
+              "types": [
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "B",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "C",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 24
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 19
+                },
+                "end": {
+                  "line": 11,
+                  "column": 24
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 18
+              },
+              "end": {
+                "line": 11,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "D",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 28
+                },
+                "end": {
+                  "line": 11,
+                  "column": 29
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 28
+              },
+              "end": {
+                "line": 11,
+                "column": 29
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 14
+          },
+          "end": {
+            "line": 11,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 29
+        },
+        "end": {
+          "line": 11,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type5",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 6
+          },
+          "end": {
+            "line": 12,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSIntersectionType",
+            "types": [
+              {
+                "type": "TSParenthesizedType",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "A",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 12,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSIntersectionType",
+                      "types": [
+                        {
+                          "type": "TSParenthesizedType",
+                          "typeAnnotation": {
+                            "type": "TSIntersectionType",
+                            "types": [
+                              {
+                                "type": "TSTypeReference",
+                                "typeName": {
+                                  "type": "Identifier",
+                                  "name": "B",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 12,
+                                      "column": 20
+                                    },
+                                    "end": {
+                                      "line": 12,
+                                      "column": 21
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 12,
+                                    "column": 20
+                                  },
+                                  "end": {
+                                    "line": 12,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              {
+                                "type": "TSTypeReference",
+                                "typeName": {
+                                  "type": "Identifier",
+                                  "name": "C",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 12,
+                                      "column": 24
+                                    },
+                                    "end": {
+                                      "line": 12,
+                                      "column": 25
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 12,
+                                    "column": 24
+                                  },
+                                  "end": {
+                                    "line": 12,
+                                    "column": 25
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 12,
+                                "column": 20
+                              },
+                              "end": {
+                                "line": 12,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 12,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 12,
+                              "column": 26
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSTypeReference",
+                          "typeName": {
+                            "type": "Identifier",
+                            "name": "D",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 12,
+                                "column": 29
+                              },
+                              "end": {
+                                "line": 12,
+                                "column": 30
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 12,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 12,
+                              "column": 30
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 30
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 31
+                  }
+                }
+              },
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "E",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 34
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 35
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 35
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 14
+              },
+              "end": {
+                "line": 12,
+                "column": 35
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "F",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 38
+                },
+                "end": {
+                  "line": 12,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 38
+              },
+              "end": {
+                "line": 12,
+                "column": 39
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 14
+          },
+          "end": {
+            "line": 12,
+            "column": 39
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 39
+        },
+        "end": {
+          "line": 12,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSIntersectionType",
+                  "types": [
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 18
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 18
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 8
+                },
+                "end": {
+                  "line": 14,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 5
+            },
+            "end": {
+              "line": 14,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 14,
+      "column": 19
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-intersection.ts b/es2panda/test/parser/ts/test-intersection.ts
new file mode 100644
index 0000000000000000000000000000000000000000..87ba8cb25a25f5655052e2316f3f4034d19bada9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection.ts
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type A = string;
+type B = string;
+type C = string;
+type D = string;
+type E = string;
+type F = string;
+
+type Type1 = (A | & B) & (& C | D);
+type Type2 = A & (| C | D) | B & (C | D)
+type Type3 = A & C | A & D | B & C | B & D;
+type Type4 = A & (B & C) & D;
+type Type5 = (A | (B & C) & D) & E | F;
+
+var a: | & string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-intersection1-expected.txt b/es2panda/test/parser/ts/test-intersection1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b9ee98ca1e06ed3a69968affa5e568967e5b22bc
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-intersection1.ts:1:10]
diff --git a/es2panda/test/parser/ts/test-intersection1.ts b/es2panda/test/parser/ts/test-intersection1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..557f5292023b24120b2a8bb8405ab3c929853711
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: & | string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-intersection2-expected.txt b/es2panda/test/parser/ts/test-intersection2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b25e9985fd4bd30c5a00f2d28474a1cfc7b2327a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-intersection2.ts:1:10]
diff --git a/es2panda/test/parser/ts/test-intersection2.ts b/es2panda/test/parser/ts/test-intersection2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae6eb195cc042d71cea16d6ab5eb140578629868
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: & & string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-intersection3-expected.txt b/es2panda/test/parser/ts/test-intersection3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afe0ede959c37e2dd71a3301da733e8ac2783954
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-intersection3.ts:1:16]
diff --git a/es2panda/test/parser/ts/test-intersection3.ts b/es2panda/test/parser/ts/test-intersection3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc11fef3f5981badd5f762f5cfea8d251b0ff200
--- /dev/null
+++ b/es2panda/test/parser/ts/test-intersection3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: string &;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare-expected.txt b/es2panda/test/parser/ts/test-keyword-declare-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..17d1f36fe50184b7fdd02623f32ccb42bab9a7b9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare-expected.txt
@@ -0,0 +1,1257 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var1",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var2",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 13
+              },
+              "end": {
+                "line": 2,
+                "column": 17
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 13
+            },
+            "end": {
+              "line": 2,
+              "column": 17
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "declare": true,
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 9
+        },
+        "end": {
+          "line": 2,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var3",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var4",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 13
+              },
+              "end": {
+                "line": 5,
+                "column": 17
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 13
+            },
+            "end": {
+              "line": 5,
+              "column": 17
+            }
+          }
+        }
+      ],
+      "kind": "let",
+      "declare": true,
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 9
+        },
+        "end": {
+          "line": 5,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var5",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 7
+              },
+              "end": {
+                "line": 7,
+                "column": 11
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 14
+              },
+              "end": {
+                "line": 7,
+                "column": 15
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 7
+            },
+            "end": {
+              "line": 7,
+              "column": 15
+            }
+          }
+        }
+      ],
+      "kind": "const",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var6",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 15
+              },
+              "end": {
+                "line": 8,
+                "column": 19
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 4,
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 22
+              },
+              "end": {
+                "line": 8,
+                "column": 23
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 15
+            },
+            "end": {
+              "line": 8,
+              "column": 23
+            }
+          }
+        }
+      ],
+      "kind": "const",
+      "declare": true,
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 9
+        },
+        "end": {
+          "line": 8,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var7",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 15
+              },
+              "end": {
+                "line": 9,
+                "column": 19
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 15
+            },
+            "end": {
+              "line": 9,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "const",
+      "declare": true,
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 9
+        },
+        "end": {
+          "line": 9,
+          "column": 20
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "type1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 6
+          },
+          "end": {
+            "line": 11,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 14
+              },
+              "end": {
+                "line": 11,
+                "column": 20
+              }
+            }
+          },
+          {
+            "type": "TSStringKeyword",
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 23
+              },
+              "end": {
+                "line": 11,
+                "column": 29
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 14
+          },
+          "end": {
+            "line": 11,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 29
+        },
+        "end": {
+          "line": 11,
+          "column": 30
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "type2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 14
+          },
+          "end": {
+            "line": 12,
+            "column": 19
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 22
+              },
+              "end": {
+                "line": 12,
+                "column": 28
+              }
+            }
+          },
+          {
+            "type": "TSStringKeyword",
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 31
+              },
+              "end": {
+                "line": 12,
+                "column": 37
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 12,
+            "column": 22
+          },
+          "end": {
+            "line": 12,
+            "column": 37
+          }
+        }
+      },
+      "declare": true,
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 9
+        },
+        "end": {
+          "line": 12,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 37
+        },
+        "end": {
+          "line": 12,
+          "column": 38
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 10
+            },
+            "end": {
+              "line": 14,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 14,
+              "column": 18
+            },
+            "end": {
+              "line": 14,
+              "column": 21
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 14,
+            "column": 1
+          },
+          "end": {
+            "line": 14,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 14,
+          "column": 21
+        },
+        "end": {
+          "line": 14,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 18
+            },
+            "end": {
+              "line": 15,
+              "column": 23
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 15,
+            "column": 9
+          },
+          "end": {
+            "line": 15,
+            "column": 26
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 9
+        },
+        "end": {
+          "line": 15,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 1
+            },
+            "end": {
+              "line": 16,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 1
+          },
+          "end": {
+            "line": 16,
+            "column": 8
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Class1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 15
+            },
+            "end": {
+              "line": 18,
+              "column": 21
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 9
+            },
+            "end": {
+              "line": 29,
+              "column": 2
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 24
+                },
+                "end": {
+                  "line": 19,
+                  "column": 25
+                }
+              }
+            },
+            "kind": "get",
+            "accessibility": "private",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 25
+                },
+                "end": {
+                  "line": 20,
+                  "column": 11
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "g",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 12
+                },
+                "end": {
+                  "line": 20,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 13
+                },
+                "end": {
+                  "line": 21,
+                  "column": 11
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 5,
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 30
+                },
+                "end": {
+                  "line": 21,
+                  "column": 31
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 31
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "StringLiteral",
+              "value": "",
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 30
+                },
+                "end": {
+                  "line": 22,
+                  "column": 33
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": true,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 5
+              },
+              "end": {
+                "line": 22,
+                "column": 33
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 67,
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 29
+                },
+                "end": {
+                  "line": 23,
+                  "column": 31
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 5
+              },
+              "end": {
+                "line": 23,
+                "column": 31
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "j",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 29
+                },
+                "end": {
+                  "line": 24,
+                  "column": 30
+                }
+              }
+            },
+            "static": true,
+            "readonly": true,
+            "declare": true,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 5
+              },
+              "end": {
+                "line": 24,
+                "column": 30
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "private",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 5
+                },
+                "end": {
+                  "line": 25,
+                  "column": 12
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 12
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 16
+                },
+                "end": {
+                  "line": 26,
+                  "column": 17
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "protected",
+            "static": false,
+            "optional": false,
+            "computed": true,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 18
+                },
+                "end": {
+                  "line": 27,
+                  "column": 11
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 27,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "k",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 19
+                },
+                "end": {
+                  "line": 27,
+                  "column": 20
+                }
+              }
+            },
+            "accessibility": "public",
+            "static": true,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 5
+              },
+              "end": {
+                "line": 27,
+                "column": 20
+              }
+            }
+          },
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "TSPrivateIdentifier",
+              "key": {
+                "type": "Identifier",
+                "name": "o",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 7
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 5
+                },
+                "end": {
+                  "line": 28,
+                  "column": 7
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 7
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 22
+          },
+          "end": {
+            "line": 29,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 9
+        },
+        "end": {
+          "line": 29,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 29,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-keyword-declare.ts b/es2panda/test/parser/ts/test-keyword-declare.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e42283e57cd3fe504534cd36b28be5d761c02269
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare.ts
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var var1;
+declare var var2;
+
+let var3;
+declare let var4;
+
+const var5 = 1;
+declare const var6 = 4;
+declare const var7;
+
+type type1 = number | string;
+declare type type2 = number | string;
+
+function func1() { };
+declare function func2();
+func2();
+
+declare class Class1 {
+    private static get a()
+    public g()
+    static declare readonly [5]
+    static declare readonly ["b"]
+    static readonly declare 67
+    declare static readonly j
+    private;
+    protected [1]()
+    public static k
+    #o;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare1-expected.txt b/es2panda/test/parser/ts/test-keyword-declare1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d6958452d732bd25b1f099bebe899b6fd7b27b8e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Initializers are not allowed in ambient contexts. [test-keyword-declare1.ts:1:17]
diff --git a/es2panda/test/parser/ts/test-keyword-declare1.ts b/es2panda/test/parser/ts/test-keyword-declare1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..11d8dce914debc71e63bf228b05d537644d855ef
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare var a = 5;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare10-expected.txt b/es2panda/test/parser/ts/test-keyword-declare10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..616187a17bdd9cf1664017fb4d684e36528026d5
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare10-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Generators are not allowed in an ambient context. [test-keyword-declare10.ts:2:14]
diff --git a/es2panda/test/parser/ts/test-keyword-declare10.ts b/es2panda/test/parser/ts/test-keyword-declare10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7e147ac870bec436452de4799743dfb1bc26e457
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare class Foo {
+    public *g()
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare11-expected.txt b/es2panda/test/parser/ts/test-keyword-declare11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2e172d450b6bbf0af82ee5a713316ca8b2f362ec
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare11-expected.txt
@@ -0,0 +1 @@
+SyntaxError: An implementation cannot be declared in ambient contexts. [test-keyword-declare11.ts:2:16]
diff --git a/es2panda/test/parser/ts/test-keyword-declare11.ts b/es2panda/test/parser/ts/test-keyword-declare11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..30ba7d50614f4c75b0b407558711ce8cd3e325d5
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare class Foo {
+    public g() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare12-expected.txt b/es2panda/test/parser/ts/test-keyword-declare12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8d798133319779d8db498fa81fee9d44885954d9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare12-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Initializers are not allowed in ambient contexts. [test-keyword-declare12.ts:2:24]
diff --git a/es2panda/test/parser/ts/test-keyword-declare12.ts b/es2panda/test/parser/ts/test-keyword-declare12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..18e1fcb088d0d29b58ed5905c40a7ad41d7664a9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare class Foo {
+    private static a = 3;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare13-expected.txt b/es2panda/test/parser/ts/test-keyword-declare13-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a823f7452dba46f8f3e8e081d29b0d9a753af094
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare13-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Initializers are not allowed in ambient contexts. [test-keyword-declare13.ts:2:32]
diff --git a/es2panda/test/parser/ts/test-keyword-declare13.ts b/es2panda/test/parser/ts/test-keyword-declare13.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d3b1056681764bcc476e7099b9b06e133e1cfde2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare13.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    private static declare a = 3;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare2-expected.txt b/es2panda/test/parser/ts/test-keyword-declare2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cab2da2354d86118fe32171983f60ea439bbf920
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Initializers are not allowed in ambient contexts. [test-keyword-declare2.ts:1:17]
diff --git a/es2panda/test/parser/ts/test-keyword-declare2.ts b/es2panda/test/parser/ts/test-keyword-declare2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f70a9e05651f4145bc88f82695d9dce6a01af881
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare let a = 5;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare3-expected.txt b/es2panda/test/parser/ts/test-keyword-declare3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..10a9c2cb0a06888a86e0f0072081478a8dfb4c1e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token. [test-keyword-declare3.ts:1:9]
diff --git a/es2panda/test/parser/ts/test-keyword-declare3.ts b/es2panda/test/parser/ts/test-keyword-declare3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d3c876d82a28346da1985d2339a5cbcf4b46ec46
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare a = 5;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare4-expected.txt b/es2panda/test/parser/ts/test-keyword-declare4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..db367c69a7f27bf6ea25060c95b425cfb6c18dc9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: An implementation cannot be declared in ambient contexts. [test-keyword-declare4.ts:1:22]
diff --git a/es2panda/test/parser/ts/test-keyword-declare4.ts b/es2panda/test/parser/ts/test-keyword-declare4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5c726c99823a6c3c53ff9ea2f065bf0723549014
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare function a() { };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare5-expected.txt b/es2panda/test/parser/ts/test-keyword-declare5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..517cc4f30032445f910d823a948f77dafceddcb0
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare5-expected.txt
@@ -0,0 +1,106 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 14
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 18
+            },
+            "end": {
+              "line": 2,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 9
+          },
+          "end": {
+            "line": 2,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 9
+        },
+        "end": {
+          "line": 2,
+          "column": 22
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 22
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-keyword-declare5.ts b/es2panda/test/parser/ts/test-keyword-declare5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0026a71fc265b874de52f11fc89746673bcd5d7b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare5.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function a();
+declare function a();
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare6-expected.txt b/es2panda/test/parser/ts/test-keyword-declare6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c99ec39c5601f36aa98c51ebc338b41a3193f71f
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare6-expected.txt
@@ -0,0 +1,146 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 18
+            },
+            "end": {
+              "line": 1,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 9
+          },
+          "end": {
+            "line": 1,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 9
+        },
+        "end": {
+          "line": 1,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 21
+        },
+        "end": {
+          "line": 1,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 14
+            },
+            "end": {
+              "line": 2,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 17
+        },
+        "end": {
+          "line": 2,
+          "column": 18
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 2,
+      "column": 18
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-keyword-declare6.ts b/es2panda/test/parser/ts/test-keyword-declare6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f2fb4f6ea6b8b10f1a70a36d221b98ea4ead9447
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare6.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare function a();
+function a() { };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare7-expected.txt b/es2panda/test/parser/ts/test-keyword-declare7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..70dc5407991a285fb37009ceba2d9bae017939f7
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare7-expected.txt
@@ -0,0 +1,191 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 18
+            },
+            "end": {
+              "line": 1,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "declare": true,
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 9
+          },
+          "end": {
+            "line": 1,
+            "column": 22
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 9
+        },
+        "end": {
+          "line": 1,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 10
+            },
+            "end": {
+              "line": 3,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 14
+            },
+            "end": {
+              "line": 3,
+              "column": 17
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 17
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 17
+        },
+        "end": {
+          "line": 3,
+          "column": 18
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 3,
+      "column": 18
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-keyword-declare7.ts b/es2panda/test/parser/ts/test-keyword-declare7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..732c16c18ca06481912322ba42a5deeb7faf13fb
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare function a();
+var b = 5;
+function a() { };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare8-expected.txt b/es2panda/test/parser/ts/test-keyword-declare8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..20abeb87a2c00fb1fd3d31fb1c6b6951ba0563e8
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare8-expected.txt
@@ -0,0 +1 @@
+SyntaxError: An implementation cannot be declared in ambient contexts. [test-keyword-declare8.ts:2:28]
diff --git a/es2panda/test/parser/ts/test-keyword-declare8.ts b/es2panda/test/parser/ts/test-keyword-declare8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..66435c36aa38eb8859dc32e86a553dfe90959435
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare class Foo {
+    private static get a() { return }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-keyword-declare9-expected.txt b/es2panda/test/parser/ts/test-keyword-declare9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..559c6dc3621417668831062c9e7e14e05c9ea487
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare9-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'async' modifier cannot be used in an ambient context. [test-keyword-declare9.ts:2:19]
diff --git a/es2panda/test/parser/ts/test-keyword-declare9.ts b/es2panda/test/parser/ts/test-keyword-declare9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4f885b6c3b6228a4b150c6cdde0e57a787b7ef18
--- /dev/null
+++ b/es2panda/test/parser/ts/test-keyword-declare9.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare class Foo {
+    public async g()
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-member-expression1-expected.txt b/es2panda/test/parser/ts/test-member-expression1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..89bb37a42ef893b1f76a259e988d5b1f44d38dfa
--- /dev/null
+++ b/es2panda/test/parser/ts/test-member-expression1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Invalid left-hand side in assignment expression [test-member-expression1.ts:2:18]
diff --git a/es2panda/test/parser/ts/test-member-expression1.ts b/es2panda/test/parser/ts/test-member-expression1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9363c4cfad99dfb7a8eacee7799c629fb01d5586
--- /dev/null
+++ b/es2panda/test/parser/ts/test-member-expression1.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = {foo : {bar : {baz : 5}}};
+a?.foo?.bar?.baz = a?.foo?.bar?.baz;
diff --git a/es2panda/test/parser/ts/test-member-expression2-expected.txt b/es2panda/test/parser/ts/test-member-expression2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a015d3225681e42e62da377963ea6f62766d3bfa
--- /dev/null
+++ b/es2panda/test/parser/ts/test-member-expression2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Invalid left-hand side in assignment expression [test-member-expression2.ts:2:8]
diff --git a/es2panda/test/parser/ts/test-member-expression2.ts b/es2panda/test/parser/ts/test-member-expression2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bf7f7667c2c70150922ab359eb7bb31b36a952d5
--- /dev/null
+++ b/es2panda/test/parser/ts/test-member-expression2.ts
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = [0, 1, 2, 3, 4];
+a?.[0] = a?.[0];
diff --git a/es2panda/test/parser/ts/test-ts-as-expression-expected.txt b/es2panda/test/parser/ts/test-ts-as-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50da7b2455f3bf4f64844514176c13c8b50b8cd6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-as-expression-expected.txt
@@ -0,0 +1,418 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "StringLiteral",
+              "value": "x",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 9
+                },
+                "end": {
+                  "line": 1,
+                  "column": 12
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "StringLiteral",
+                    "value": "x",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "StringLiteral",
+                    "value": "y",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 16
+                },
+                "end": {
+                  "line": 1,
+                  "column": 25
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 26
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 26
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 26
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "TSAsExpression",
+              "expression": {
+                "type": "TSAsExpression",
+                "expression": {
+                  "type": "NullLiteral",
+                  "value": null,
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 13
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSAnyKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 23
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 30
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSUndefinedKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 42
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 42
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 9
+                },
+                "end": {
+                  "line": 2,
+                  "column": 45
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNeverKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 46
+                },
+                "end": {
+                  "line": 2,
+                  "column": 51
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 9
+              },
+              "end": {
+                "line": 2,
+                "column": 52
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 52
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 52
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "TSAsExpression",
+            "expression": {
+              "type": "NumberLiteral",
+              "value": 1,
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 9
+                },
+                "end": {
+                  "line": 3,
+                  "column": 10
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "const",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 14
+                },
+                "end": {
+                  "line": 3,
+                  "column": 19
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 9
+              },
+              "end": {
+                "line": 3,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 20
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 20
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 1
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-as-expression.ts b/es2panda/test/parser/ts/test-ts-as-expression.ts
new file mode 100644
index 0000000000000000000000000000000000000000..64d150e2bd10039b68ce58ca199daa6ab882f474
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-as-expression.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = "x" as "x" | "y";
+var b = null as any as string | undefined as never;
+var c = 1 as const;
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5b7c2a518ad5bc2f03872778d72e7d8f4c865434
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type-expected.txt
@@ -0,0 +1,1762 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 5,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 9
+              },
+              "end": {
+                "line": 1,
+                "column": 10
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "A",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 6
+          },
+          "end": {
+            "line": 2,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSConditionalType",
+        "checkType": {
+          "type": "TSArrayType",
+          "elementType": {
+            "type": "TSParenthesizedType",
+            "typeAnnotation": {
+              "type": "TSConditionalType",
+              "checkType": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 17
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSIntersectionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 26
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 36
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 36
+                  }
+                }
+              },
+              "extendsType": {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 52
+                  }
+                }
+              },
+              "trueType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 61
+                  }
+                }
+              },
+              "falseType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 64
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 70
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 11
+                },
+                "end": {
+                  "line": 2,
+                  "column": 70
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 10
+              },
+              "end": {
+                "line": 2,
+                "column": 71
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 10
+            },
+            "end": {
+              "line": 2,
+              "column": 73
+            }
+          }
+        },
+        "extendsType": {
+          "type": "TSParenthesizedType",
+          "typeAnnotation": {
+            "type": "TSUnionType",
+            "types": [
+              {
+                "type": "TSParenthesizedType",
+                "typeAnnotation": {
+                  "type": "TSConditionalType",
+                  "checkType": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 84
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 91
+                      }
+                    }
+                  },
+                  "extendsType": {
+                    "type": "TSIntersectionType",
+                    "types": [
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 102
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 108
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 100
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 108
+                      }
+                    }
+                  },
+                  "trueType": {
+                    "type": "TSTypeQuery",
+                    "exprName": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 2,
+                          "column": 118
+                        },
+                        "end": {
+                          "line": 2,
+                          "column": 119
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 111
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 119
+                      }
+                    }
+                  },
+                  "falseType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 122
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 128
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 84
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 128
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 83
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 129
+                  }
+                }
+              },
+              {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 132
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 138
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 83
+              },
+              "end": {
+                "line": 2,
+                "column": 138
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 82
+            },
+            "end": {
+              "line": 2,
+              "column": 139
+            }
+          }
+        },
+        "trueType": {
+          "type": "TSConditionalType",
+          "checkType": {
+            "type": "TSUnionType",
+            "types": [
+              {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 142
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 148
+                  }
+                }
+              },
+              {
+                "type": "TSBooleanKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 151
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 158
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 142
+              },
+              "end": {
+                "line": 2,
+                "column": 158
+              }
+            }
+          },
+          "extendsType": {
+            "type": "TSStringKeyword",
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 167
+              },
+              "end": {
+                "line": 2,
+                "column": 173
+              }
+            }
+          },
+          "trueType": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 176
+              },
+              "end": {
+                "line": 2,
+                "column": 182
+              }
+            }
+          },
+          "falseType": {
+            "type": "TSStringKeyword",
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 185
+              },
+              "end": {
+                "line": 2,
+                "column": 191
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 142
+            },
+            "end": {
+              "line": 2,
+              "column": 191
+            }
+          }
+        },
+        "falseType": {
+          "type": "TSStringKeyword",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 194
+            },
+            "end": {
+              "line": 2,
+              "column": 200
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 10
+          },
+          "end": {
+            "line": 2,
+            "column": 200
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 201
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 200
+        },
+        "end": {
+          "line": 2,
+          "column": 201
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSConditionalType",
+              "checkType": {
+                "type": "TSIntersectionType",
+                "types": [
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 24
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 24
+                  }
+                }
+              },
+              "extendsType": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "A",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 34
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 34
+                  }
+                }
+              },
+              "trueType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 43
+                  }
+                }
+              },
+              "falseType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 46
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 52
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 52
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 53
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSConditionalType",
+              "checkType": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSTypeReference",
+                    "typeName": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 9
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 18
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 18
+                  }
+                }
+              },
+              "extendsType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 33
+                  }
+                }
+              },
+              "trueType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 42
+                  }
+                }
+              },
+              "falseType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 51
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 51
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 52
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSConditionalType",
+              "checkType": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 15
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSIntersectionType",
+                    "types": [
+                      {
+                        "type": "TSTypeReference",
+                        "typeName": {
+                          "type": "Identifier",
+                          "name": "A",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 6,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 6,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 19
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 28
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 28
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 28
+                  }
+                }
+              },
+              "extendsType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 43
+                  }
+                }
+              },
+              "trueType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 46
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 52
+                  }
+                }
+              },
+              "falseType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 61
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 61
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSConditionalType",
+              "checkType": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSIntersectionType",
+                    "types": [
+                      {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 8
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 15
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 24
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 24
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 33
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 33
+                  }
+                }
+              },
+              "extendsType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 48
+                  }
+                }
+              },
+              "trueType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 51
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 57
+                  }
+                }
+              },
+              "falseType": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 60
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 66
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 66
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 67
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Bar",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 6
+          },
+          "end": {
+            "line": 9,
+            "column": 9
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSConditionalType",
+        "checkType": {
+          "type": "TSTypeReference",
+          "typeName": {
+            "type": "Identifier",
+            "name": "T",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 15
+              },
+              "end": {
+                "line": 9,
+                "column": 16
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 15
+            },
+            "end": {
+              "line": 9,
+              "column": 16
+            }
+          }
+        },
+        "extendsType": {
+          "type": "TSArrayType",
+          "elementType": {
+            "type": "TSParenthesizedType",
+            "typeAnnotation": {
+              "type": "TSInferType",
+              "typeParameter": {
+                "type": "TSTypeParameter",
+                "name": {
+                  "type": "Identifier",
+                  "name": "U",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 33
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 34
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 26
+                },
+                "end": {
+                  "line": 9,
+                  "column": 34
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 25
+              },
+              "end": {
+                "line": 9,
+                "column": 34
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 25
+            },
+            "end": {
+              "line": 9,
+              "column": 36
+            }
+          }
+        },
+        "trueType": {
+          "type": "TSTypeReference",
+          "typeName": {
+            "type": "Identifier",
+            "name": "U",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 7
+              },
+              "end": {
+                "line": 10,
+                "column": 8
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 7
+            },
+            "end": {
+              "line": 10,
+              "column": 8
+            }
+          }
+        },
+        "falseType": {
+          "type": "TSConditionalType",
+          "checkType": {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 7
+                },
+                "end": {
+                  "line": 11,
+                  "column": 8
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 7
+              },
+              "end": {
+                "line": 11,
+                "column": 8
+              }
+            }
+          },
+          "extendsType": {
+            "type": "TSFunctionType",
+            "params": [
+              {
+                "type": "RestElement",
+                "argument": {
+                  "type": "Identifier",
+                  "name": "args",
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSAnyKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 27
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 30
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 25
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSInferType",
+              "typeParameter": {
+                "type": "TSTypeParameter",
+                "name": {
+                  "type": "Identifier",
+                  "name": "U",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 44
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 6
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 37
+                },
+                "end": {
+                  "line": 12,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 17
+              },
+              "end": {
+                "line": 12,
+                "column": 6
+              }
+            }
+          },
+          "trueType": {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "U",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 7
+                },
+                "end": {
+                  "line": 12,
+                  "column": 8
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 7
+              },
+              "end": {
+                "line": 12,
+                "column": 8
+              }
+            }
+          },
+          "falseType": {
+            "type": "TSConditionalType",
+            "checkType": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 8
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 7
+                },
+                "end": {
+                  "line": 13,
+                  "column": 8
+                }
+              }
+            },
+            "extendsType": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Promise",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 24
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSInferType",
+                    "typeParameter": {
+                      "type": "TSTypeParameter",
+                      "name": {
+                        "type": "Identifier",
+                        "name": "U",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 33
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 33
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 33
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 17
+                },
+                "end": {
+                  "line": 13,
+                  "column": 24
+                }
+              }
+            },
+            "trueType": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "U",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 14,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 14,
+                    "column": 8
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 7
+                },
+                "end": {
+                  "line": 14,
+                  "column": 8
+                }
+              }
+            },
+            "falseType": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 8
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 7
+                },
+                "end": {
+                  "line": 15,
+                  "column": 8
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 7
+              },
+              "end": {
+                "line": 15,
+                "column": 8
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 7
+            },
+            "end": {
+              "line": 15,
+              "column": 8
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 15
+          },
+          "end": {
+            "line": 15,
+            "column": 8
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 10
+                },
+                "end": {
+                  "line": 9,
+                  "column": 11
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 10
+              },
+              "end": {
+                "line": 9,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 9,
+            "column": 9
+          },
+          "end": {
+            "line": 9,
+            "column": 12
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 9
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 8
+        },
+        "end": {
+          "line": 15,
+          "column": 9
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 15,
+      "column": 9
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type.ts b/es2panda/test/parser/ts/test-ts-conditional-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..afeec0ad7fdf174e670d02244e1165b2a13c1096
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type.ts
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a = 5;
+type A = (string | number & boolean extends boolean ? number : string)[] extends ((boolean extends & string ? typeof a : number) | number) ? number | boolean extends string ? number : string : string;
+
+var b: boolean & number extends A ? number : string;
+var c: A | number extends string ? number : string;
+var d: boolean | A & string extends string ? number : string;
+var e: boolean & number | string extends string ? number : string;
+
+type Bar<T> = T extends (infer U)[]
+    ? U
+    : T extends (...args: any[]) => infer U
+    ? U
+    : T extends Promise<infer U>
+    ? U
+    : T;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type1-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b8ba53ba6c353e484980e35ecf2e71533b1863d0
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '?' expected. [test-ts-conditional-type1.ts:1:34]
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type1.ts b/es2panda/test/parser/ts/test-ts-conditional-type1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..45adf005fea5a2daef30f6e9628fb7e170742bbd
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo = string extends number extends string ?number: string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type2-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..81076cb884969a286120e3cfe4651b2792172c99
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-ts-conditional-type2.ts:1:51]
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type2.ts b/es2panda/test/parser/ts/test-ts-conditional-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ce3c9812afc6a4e0155d2e534dcc4941ad16cae7
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo = string extends number ? number extends : string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type3-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d2ef83010f2e37e7bcf65744433baa3bd11f0e9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ':' expected. [test-ts-conditional-type3.ts:1:43]
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type3.ts b/es2panda/test/parser/ts/test-ts-conditional-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6ec7f2aa299f7a622f09b1f0eddad5542aeaa83c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo = string extends number ? number string : string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type4-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..62dcf61f7d3ad95f9bc5c7dbaf9586e22f2e677d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-ts-conditional-type4.ts:1:59]
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type4.ts b/es2panda/test/parser/ts/test-ts-conditional-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5fa65b4d13b99f91d8920d50755b4e83d4dbfc8f
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo = string extends number ? number : string extends;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type5-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fc4d96e48cc402a44df240b4178577a52fb5ca00
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. [test-ts-conditional-type5.ts:1:12]
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type5.ts b/es2panda/test/parser/ts/test-ts-conditional-type5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb455ddb182447e1b6f66da955266bc00435ff11
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo = infer string extends number ? number : string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type6-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53f3aad80dfceb4156089c6b11bb4b40697a4ce6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. [test-ts-conditional-type6.ts:1:36]
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type6.ts b/es2panda/test/parser/ts/test-ts-conditional-type6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4b1a534e39589059590c25ae117a03f09e60b80d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo = string extends number ? infer number : string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type7-expected.txt b/es2panda/test/parser/ts/test-ts-conditional-type7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e06a986353c0edfa75ef677e6c12aa955a6ae4b1
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'infer' declarations are only permitted in the 'extends' clause of a conditional type. [test-ts-conditional-type7.ts:1:45]
diff --git a/es2panda/test/parser/ts/test-ts-conditional-type7.ts b/es2panda/test/parser/ts/test-ts-conditional-type7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3b2466bd8ea48dad0620dee731dd9423ae219f06
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-conditional-type7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo = string extends number ? number : infer string;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type1-expected.txt b/es2panda/test/parser/ts/test-ts-constructor-type1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bfbbfeb41763abb92da63e1e48c7707e87c21a06
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '=>' expected [test-ts-constructor-type1.ts:1:37]
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type1.ts b/es2panda/test/parser/ts/test-ts-constructor-type1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4d4e96673bc9140400653190e691a3cc162baa8b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var ctor: new (a: number, b: string);
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type2-expected.txt b/es2panda/test/parser/ts/test-ts-constructor-type2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..141a4e92799cc4cc35740a71ecf9acce24a6c945
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '=>' expected [test-ts-constructor-type2.ts:1:46]
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type2.ts b/es2panda/test/parser/ts/test-ts-constructor-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e6dcf24d0d1cfade38089f376e76744ced1b2f36
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var ctor: abstract new (a: number, b: string);
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type3-expected.txt b/es2panda/test/parser/ts/test-ts-constructor-type3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..18cf2c88069f143e563178993bf84017281b746d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '(' expected [test-ts-constructor-type3.ts:1:16]
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type3.ts b/es2panda/test/parser/ts/test-ts-constructor-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..28c51cc0fe2ff4242d84f7bb7f806931035e1134
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var ctor1: new abstract (a: number, b: string) => number;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type4-expected.txt b/es2panda/test/parser/ts/test-ts-constructor-type4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fcf4ec0e2bfb88274773e4ef716853be66f925ef
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-constructor-type4.ts:1:21]
diff --git a/es2panda/test/parser/ts/test-ts-constructor-type4.ts b/es2panda/test/parser/ts/test-ts-constructor-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d4df308c5723a771e881255400c69a0676c651c0
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-constructor-type4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var ctor1: abstract (a: number, b: string) => number;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6b67f5e6640294354da361da25276fa64574f841
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type-expected.txt
@@ -0,0 +1,1255 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSMappedType",
+        "typeParameter": {
+          "type": "TSTypeParameter",
+          "name": {
+            "type": "Identifier",
+            "name": "prop",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 31
+              },
+              "end": {
+                "line": 1,
+                "column": 35
+              }
+            }
+          },
+          "constraint": {
+            "type": "TSTypeOperator",
+            "operator": "keyof",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T1",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 47
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 45
+                },
+                "end": {
+                  "line": 1,
+                  "column": 47
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 39
+              },
+              "end": {
+                "line": 1,
+                "column": 47
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 31
+            },
+            "end": {
+              "line": 1,
+              "column": 47
+            }
+          }
+        },
+        "typeAnnotation": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 52
+            },
+            "end": {
+              "line": 1,
+              "column": 59
+            }
+          }
+        },
+        "readonly": "-",
+        "optional": "-",
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 18
+          },
+          "end": {
+            "line": 1,
+            "column": 62
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T1",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 12
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 12
+              },
+              "end": {
+                "line": 1,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 62
+        },
+        "end": {
+          "line": 1,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 6
+          },
+          "end": {
+            "line": 2,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSMappedType",
+        "typeParameter": {
+          "type": "TSTypeParameter",
+          "name": {
+            "type": "Identifier",
+            "name": "prop",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 31
+              },
+              "end": {
+                "line": 2,
+                "column": 35
+              }
+            }
+          },
+          "constraint": {
+            "type": "TSTypeOperator",
+            "operator": "keyof",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T2",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 47
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 45
+                },
+                "end": {
+                  "line": 2,
+                  "column": 47
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 39
+              },
+              "end": {
+                "line": 2,
+                "column": 47
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 31
+            },
+            "end": {
+              "line": 2,
+              "column": 47
+            }
+          }
+        },
+        "typeAnnotation": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 52
+            },
+            "end": {
+              "line": 2,
+              "column": 59
+            }
+          }
+        },
+        "readonly": "+",
+        "optional": "+",
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 18
+          },
+          "end": {
+            "line": 2,
+            "column": 62
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T2",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 12
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 11
+          },
+          "end": {
+            "line": 2,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 62
+        },
+        "end": {
+          "line": 2,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 6
+          },
+          "end": {
+            "line": 3,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSMappedType",
+        "typeParameter": {
+          "type": "TSTypeParameter",
+          "name": {
+            "type": "Identifier",
+            "name": "prop",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 30
+              },
+              "end": {
+                "line": 3,
+                "column": 34
+              }
+            }
+          },
+          "constraint": {
+            "type": "TSTypeOperator",
+            "operator": "keyof",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T3",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 46
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 44
+                },
+                "end": {
+                  "line": 3,
+                  "column": 46
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 38
+              },
+              "end": {
+                "line": 3,
+                "column": 46
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 30
+            },
+            "end": {
+              "line": 3,
+              "column": 46
+            }
+          }
+        },
+        "typeAnnotation": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 50
+            },
+            "end": {
+              "line": 3,
+              "column": 57
+            }
+          }
+        },
+        "readonly": "+",
+        "optional": "+",
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 18
+          },
+          "end": {
+            "line": 3,
+            "column": 60
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T3",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 12
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 12
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 11
+          },
+          "end": {
+            "line": 3,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 60
+        },
+        "end": {
+          "line": 3,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 6
+          },
+          "end": {
+            "line": 4,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSMappedType",
+        "typeParameter": {
+          "type": "TSTypeParameter",
+          "name": {
+            "type": "Identifier",
+            "name": "prop",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 21
+              },
+              "end": {
+                "line": 4,
+                "column": 25
+              }
+            }
+          },
+          "constraint": {
+            "type": "TSTypeOperator",
+            "operator": "keyof",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T4",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 35
+                },
+                "end": {
+                  "line": 4,
+                  "column": 37
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 29
+              },
+              "end": {
+                "line": 4,
+                "column": 37
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 21
+            },
+            "end": {
+              "line": 4,
+              "column": 37
+            }
+          }
+        },
+        "typeAnnotation": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 40
+            },
+            "end": {
+              "line": 4,
+              "column": 47
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 18
+          },
+          "end": {
+            "line": 4,
+            "column": 50
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T4",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 12
+                },
+                "end": {
+                  "line": 4,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 12
+              },
+              "end": {
+                "line": 4,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 11
+          },
+          "end": {
+            "line": 4,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 50
+        },
+        "end": {
+          "line": 4,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type5",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 6
+          },
+          "end": {
+            "line": 5,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSMappedType",
+        "typeParameter": {
+          "type": "TSTypeParameter",
+          "name": {
+            "type": "Identifier",
+            "name": "prop",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 21
+              },
+              "end": {
+                "line": 5,
+                "column": 25
+              }
+            }
+          },
+          "constraint": {
+            "type": "TSTypeOperator",
+            "operator": "keyof",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T5",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 35
+                },
+                "end": {
+                  "line": 5,
+                  "column": 37
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 29
+              },
+              "end": {
+                "line": 5,
+                "column": 37
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 21
+            },
+            "end": {
+              "line": 5,
+              "column": 37
+            }
+          }
+        },
+        "typeAnnotation": {
+          "type": "TSBooleanKeyword",
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 40
+            },
+            "end": {
+              "line": 5,
+              "column": 47
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 18
+          },
+          "end": {
+            "line": 5,
+            "column": 49
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T5",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 12
+                },
+                "end": {
+                  "line": 5,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 12
+              },
+              "end": {
+                "line": 5,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 11
+          },
+          "end": {
+            "line": 5,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 49
+        },
+        "end": {
+          "line": 5,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type6",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 6
+          },
+          "end": {
+            "line": 6,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSMappedType",
+        "typeParameter": {
+          "type": "TSTypeParameter",
+          "name": {
+            "type": "Identifier",
+            "name": "prop",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 21
+              },
+              "end": {
+                "line": 6,
+                "column": 25
+              }
+            }
+          },
+          "constraint": {
+            "type": "TSTypeOperator",
+            "operator": "keyof",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T6",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 35
+                },
+                "end": {
+                  "line": 6,
+                  "column": 37
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 29
+              },
+              "end": {
+                "line": 6,
+                "column": 37
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 21
+            },
+            "end": {
+              "line": 6,
+              "column": 37
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 18
+          },
+          "end": {
+            "line": 6,
+            "column": 41
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T6",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 12
+                },
+                "end": {
+                  "line": 6,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 12
+              },
+              "end": {
+                "line": 6,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 11
+          },
+          "end": {
+            "line": 6,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 41
+        },
+        "end": {
+          "line": 6,
+          "column": 42
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "Type7",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 6
+          },
+          "end": {
+            "line": 7,
+            "column": 11
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSMappedType",
+        "typeParameter": {
+          "type": "TSTypeParameter",
+          "name": {
+            "type": "Identifier",
+            "name": "prop",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 21
+              },
+              "end": {
+                "line": 7,
+                "column": 25
+              }
+            }
+          },
+          "constraint": {
+            "type": "TSTypeOperator",
+            "operator": "keyof",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T7",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 35
+                },
+                "end": {
+                  "line": 7,
+                  "column": 37
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 29
+              },
+              "end": {
+                "line": 7,
+                "column": 37
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 21
+            },
+            "end": {
+              "line": 7,
+              "column": 37
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 18
+          },
+          "end": {
+            "line": 7,
+            "column": 40
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T7",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 12
+                },
+                "end": {
+                  "line": 7,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 12
+              },
+              "end": {
+                "line": 7,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 11
+          },
+          "end": {
+            "line": 7,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 41
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 40
+        },
+        "end": {
+          "line": 7,
+          "column": 41
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 41
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type.ts b/es2panda/test/parser/ts/test-ts-mapped-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8fbb2ccb6b683f5491d3f98bdb09b0d0f6ee462c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Type1<T1> = { -readonly [prop in keyof T1]-?: boolean; };
+type Type2<T2> = { +readonly [prop in keyof T2]+?: boolean; };
+type Type3<T3> = { readonly [prop in keyof T3]?: boolean; };
+type Type4<T4> = { [prop in keyof T4]: boolean; };
+type Type5<T5> = { [prop in keyof T5]: boolean };
+type Type6<T6> = { [prop in keyof T6]; };
+type Type7<T7> = { [prop in keyof T7] };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type1-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7522aa60321b43b8f70a0c7877f1cb812acac732
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-mapped-type1.ts:1:17]
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type1.ts b/es2panda/test/parser/ts/test-ts-mapped-type1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e094346a7983e08e692905eb286fdd546ddf5bea
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo<T> = { + s readonly[prop in keyof T] };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type2-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7e62c4a01175cf034fc4bec7171004080e1b1819
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-mapped-type2.ts:1:26]
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type2.ts b/es2panda/test/parser/ts/test-ts-mapped-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d348090e5e127f7850cbc0f426cfa29e70bc0e53
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo<T> = { readonly + [prop in keyof T] };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type3-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..003fd040c923d10643b071ccbc479a272f6c20b5
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ']' expected [test-ts-mapped-type3.ts:1:32]
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type3.ts b/es2panda/test/parser/ts/test-ts-mapped-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0431af218f31b55bf5c1d42cabc6635218e6b2fb
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo<T> = { readonly [prop keyof T] };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type4-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d0e7a5a7b06f5472cec84c3988b9c189b38d2ef1
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ']' expected [test-ts-mapped-type4.ts:1:43]
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type4.ts b/es2panda/test/parser/ts/test-ts-mapped-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ad02fdbaa0929c36fcb294ec52c722df589e419a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo<T> = { readonly [prop in keyof T +] };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type5-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..04f2fe8e9ddf8a838e02f7883af15aa05f18ad63
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '?' expected. [test-ts-mapped-type5.ts:1:44]
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type5.ts b/es2panda/test/parser/ts/test-ts-mapped-type5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aa84e6fef45d38d9efe879f7767d08dee37f2007
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo<T> = { readonly [prop in keyof T]+-? };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type6-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f87bf92287e7c5cf386a1a842703720561a2122f
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ';' expected [test-ts-mapped-type6.ts:1:43]
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type6.ts b/es2panda/test/parser/ts/test-ts-mapped-type6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4ad902edb3818d0423e4f3e0096a4c0c574f8019
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo<T> = { readonly [prop in keyof T]3 };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type7-expected.txt b/es2panda/test/parser/ts/test-ts-mapped-type7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fe006a971b6ef809c4c697bdf7c3a1426ed436e2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '}' expected [test-ts-mapped-type7.ts:1:44]
diff --git a/es2panda/test/parser/ts/test-ts-mapped-type7.ts b/es2panda/test/parser/ts/test-ts-mapped-type7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56da301c6fa54ac7426da607ff314f300b19f226
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-mapped-type7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type Foo<T> = { readonly [prop in keyof T];3 };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-non-null-expression-expected.txt b/es2panda/test/parser/ts/test-ts-non-null-expression-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d805f00309882586c66f9ce32bb55d1d7c5b26b4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-non-null-expression-expected.txt
@@ -0,0 +1,409 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "NumberLiteral",
+            "value": 1,
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 17
+              },
+              "end": {
+                "line": 1,
+                "column": 18
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 18
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": false,
+        "argument": {
+          "type": "TSNonNullExpression",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 1
+              },
+              "end": {
+                "line": 2,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 1
+            },
+            "end": {
+              "line": 2,
+              "column": 3
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 1
+          },
+          "end": {
+            "line": 2,
+            "column": 5
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "--",
+        "prefix": false,
+        "argument": {
+          "type": "TSNonNullExpression",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 1
+              },
+              "end": {
+                "line": 3,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 1
+            },
+            "end": {
+              "line": 3,
+              "column": 3
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 5
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "--",
+        "prefix": true,
+        "argument": {
+          "type": "TSNonNullExpression",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 3
+              },
+              "end": {
+                "line": 4,
+                "column": 4
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 3
+            },
+            "end": {
+              "line": 4,
+              "column": 5
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 4,
+            "column": 1
+          },
+          "end": {
+            "line": 4,
+            "column": 5
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "prefix": true,
+        "argument": {
+          "type": "TSNonNullExpression",
+          "expression": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 3
+              },
+              "end": {
+                "line": 5,
+                "column": 4
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 3
+            },
+            "end": {
+              "line": 5,
+              "column": 5
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 5
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "Identifier",
+          "name": "a",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 1
+            },
+            "end": {
+              "line": 6,
+              "column": 2
+            }
+          }
+        },
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "+",
+          "left": {
+            "type": "TSNonNullExpression",
+            "expression": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 7
+              }
+            }
+          },
+          "right": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 10
+              },
+              "end": {
+                "line": 6,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 11
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 6,
+            "column": 1
+          },
+          "end": {
+            "line": 6,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 6,
+      "column": 12
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-non-null-expression.ts b/es2panda/test/parser/ts/test-ts-non-null-expression.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6567bffc30c7176bd859399930b1c21c24be4583
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-non-null-expression.ts
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number = 1;
+a!++;
+a!--;
+--a!;
+++a!;
+a = a! + a;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4bb89a0b9e2bc7fb7f31024e085f5600695438a7
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property-expected.txt
@@ -0,0 +1,1319 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ExampleClass1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 7
+            },
+            "end": {
+              "line": 1,
+              "column": 20
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 12
+              },
+              "end": {
+                "line": 2,
+                "column": 23
+              }
+            }
+          },
+          "kind": "constructor",
+          "accessibility": "public",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "declare",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "async",
+                    "typeAnnotation": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "StringLiteral",
+                    "value": "",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "public",
+                  "readonly": false,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "private",
+                  "readonly": false,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "protected",
+                  "readonly": false,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 7,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 7,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "undefined",
+                  "readonly": true,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "public",
+                  "readonly": true,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "e",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 26
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "private",
+                  "readonly": true,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "f",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "protected",
+                  "readonly": true,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "g",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "public",
+                  "readonly": true,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "AssignmentPattern",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "readonly",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 12,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 12,
+                            "column": 42
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 33
+                        }
+                      }
+                    },
+                    "right": {
+                      "type": "BooleanLiteral",
+                      "value": false,
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 45
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 50
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 25
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 50
+                    }
+                  }
+                },
+                {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "h",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 11
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 12
+                    }
+                  }
+                },
+                {
+                  "type": "ObjectPattern",
+                  "properties": [
+                    {
+                      "type": "Property",
+                      "method": false,
+                      "shorthand": true,
+                      "computed": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "i",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 12
+                          }
+                        }
+                      },
+                      "value": {
+                        "type": "Identifier",
+                        "name": "i",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 14,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 14,
+                            "column": 12
+                          }
+                        }
+                      },
+                      "kind": "init",
+                      "loc": {
+                        "start": {
+                          "line": 14,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 14,
+                          "column": 12
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 14,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 14,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ArrayPattern",
+                    "elements": [
+                      {
+                        "type": "Identifier",
+                        "name": "j",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 15,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 15,
+                            "column": 11
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 12
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ArrayExpression",
+                    "elements": [
+                      {
+                        "type": "StringLiteral",
+                        "value": "",
+                        "loc": {
+                          "start": {
+                            "line": 15,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 15,
+                            "column": 21
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 15,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 15,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 22
+                    }
+                  }
+                },
+                {
+                  "type": "AssignmentPattern",
+                  "left": {
+                    "type": "ObjectPattern",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": true,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "k",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 12
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "Identifier",
+                          "name": "k",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 12
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 12
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 14
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "ObjectExpression",
+                    "properties": [
+                      {
+                        "type": "Property",
+                        "method": false,
+                        "shorthand": false,
+                        "computed": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "k",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 20
+                            }
+                          }
+                        },
+                        "value": {
+                          "type": "NumberLiteral",
+                          "value": 5,
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 22
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 23
+                            }
+                          }
+                        },
+                        "kind": "init",
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 23
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "RestElement",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "rest",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 16
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 23
+                },
+                "end": {
+                  "line": 17,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 23
+              },
+              "end": {
+                "line": 17,
+                "column": 21
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 21
+            }
+          }
+        },
+        "body": [],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 21
+          },
+          "end": {
+            "line": 18,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ExampleClass2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 20
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 12
+              },
+              "end": {
+                "line": 21,
+                "column": 23
+              }
+            }
+          },
+          "kind": "constructor",
+          "accessibility": "public",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "readonly",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 37
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 23
+                },
+                "end": {
+                  "line": 21,
+                  "column": 37
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 23
+              },
+              "end": {
+                "line": 21,
+                "column": 37
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 37
+            }
+          }
+        },
+        "body": [],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 21
+          },
+          "end": {
+            "line": 22,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ExampleClass3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 7
+            },
+            "end": {
+              "line": 24,
+              "column": 20
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 12
+              },
+              "end": {
+                "line": 25,
+                "column": 23
+              }
+            }
+          },
+          "kind": "constructor",
+          "accessibility": "public",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "public",
+                  "readonly": false,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "readonly",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 23
+                },
+                "end": {
+                  "line": 25,
+                  "column": 44
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 23
+              },
+              "end": {
+                "line": 25,
+                "column": 44
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 44
+            }
+          }
+        },
+        "body": [],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 21
+          },
+          "end": {
+            "line": 26,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ExampleClass4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 28,
+              "column": 7
+            },
+            "end": {
+              "line": 28,
+              "column": 20
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 12
+              },
+              "end": {
+                "line": 29,
+                "column": 23
+              }
+            }
+          },
+          "kind": "constructor",
+          "accessibility": "public",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "TSParameterProperty",
+                  "accessibility": "undefined",
+                  "readonly": true,
+                  "static": false,
+                  "export": false,
+                  "parameter": {
+                    "type": "Identifier",
+                    "name": "readonly",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 41
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 41
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 43
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 46
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 23
+                },
+                "end": {
+                  "line": 29,
+                  "column": 46
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 23
+              },
+              "end": {
+                "line": 29,
+                "column": 46
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 29,
+              "column": 46
+            }
+          }
+        },
+        "body": [],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 28,
+            "column": 21
+          },
+          "end": {
+            "line": 30,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 28,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 30,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property.ts b/es2panda/test/parser/ts/test-ts-parameter-property.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b541e5476d1006b808b6385e268e41754b0a2775
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property.ts
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class ExampleClass1 {
+    public constructor(
+        declare = 5,
+        async: string = "async",
+        public a,
+        private b,
+        protected c,
+        readonly d,
+        public readonly e,
+        private readonly f,
+        protected readonly g,
+        public readonly readonly: boolean = false,
+        [h],
+        { i },
+        [j] = ["foo"],
+        { k } = { k: 5 },
+        ...rest) { };
+}
+
+class ExampleClass2 {
+    public constructor(readonly) { };
+}
+
+class ExampleClass3 {
+    public constructor(public readonly) { };
+}
+
+class ExampleClass4 {
+    public constructor(readonly readonly) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property1-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..efde343f5ccf26bece0e82fe5c1c88f6be03f1e6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A parameter property is only allowed in a constructor implementation. [test-ts-parameter-property1.ts:1:14]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property1.ts b/es2panda/test/parser/ts/test-ts-parameter-property1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f03903448b459cf3799311794d4f975c9aaabfee
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function Foo(public readonly a) { }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property10-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..98a384f9ec916525f4eade1c58c3ff09b4d75cd9
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property10-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A parameter property may not be declared using a binding pattern. [test-ts-parameter-property10.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property10.ts b/es2panda/test/parser/ts/test-ts-parameter-property10.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e9c462008051821ba8bcd320084ae30ad8d40906
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property10.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private readonly { bar } = { bar: 2 }) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property11-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property11-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be8681978e3b5c5f5c351e6a763adf5b6fa57ab6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property11-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A parameter property may not be declared using a binding pattern. [test-ts-parameter-property11.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property11.ts b/es2panda/test/parser/ts/test-ts-parameter-property11.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8eda48622846d017cdc4c739ae50310496b84808
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property11.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private readonly [bar]) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property12-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property12-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..11995e0f60ea508cdac91f83bf079b8fa0067d23
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property12-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A parameter property may not be declared using a binding pattern. [test-ts-parameter-property12.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property12.ts b/es2panda/test/parser/ts/test-ts-parameter-property12.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c4668e06f232f1ca4e02bdf26d2f572b1573c818
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property12.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private readonly { bar }) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property2-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ddda7c05414a32d93ac3fc5705cc5e8e6455e0d8
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A parameter property is only allowed in a constructor implementation. [test-ts-parameter-property2.ts:3:7]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property2.ts b/es2panda/test/parser/ts/test-ts-parameter-property2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e938aa0a9730c2de134069a20c08c2c34fd9cf2c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property2.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor() { };
+    a(public a) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property3-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c77be0701aba2bc0f8aa3db6c272902e66d598f1
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected modifier [test-ts-parameter-property3.ts:2:26]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property3.ts b/es2panda/test/parser/ts/test-ts-parameter-property3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1ef55194300b5eb7e79de8dee41bf8adbde835bb
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(readonly readonly readonly) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property4-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8aaa1f3ea06c2169b7aaeaa4c50c0ee9173c999c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'static' modifier cannot appear on a parameter. [test-ts-parameter-property4.ts:2:25]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property4.ts b/es2panda/test/parser/ts/test-ts-parameter-property4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ab98f17984873b6319e6c1c90a98b9e13341ed6e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private static readonly readonly) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property5-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..056434a4e79f36d4f0b856e96c7a25980726e95d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'async' modifier cannot appear on a parameter. [test-ts-parameter-property5.ts:2:25]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property5.ts b/es2panda/test/parser/ts/test-ts-parameter-property5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..904691b137d84232fff82d715c3bd5fa083895e3
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private async readonly readonly) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property6-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..41f525a299f1f907b490847c1abc70fd01f346e1
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: 'declare' modifier cannot appear on a parameter. [test-ts-parameter-property6.ts:2:25]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property6.ts b/es2panda/test/parser/ts/test-ts-parameter-property6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d3b3cb12c1651140498a5845906c167e32c4d466
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property6.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private declare readonly readonly) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property7-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5522cad32b6c95f418519060dc3cdc82da2d4271
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Strict mode function may not have duplicate parameter names [test-ts-parameter-property7.ts:2:61]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property7.ts b/es2panda/test/parser/ts/test-ts-parameter-property7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ccac0696d632b329f9f9f4b733c0541447783d01
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private readonly readonly, private readonly readonly) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property8-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ab7edd86b2b4741e1e1c90a309e198e25412762e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property8-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A parameter property cannot be declared using a rest parameter. [test-ts-parameter-property8.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property8.ts b/es2panda/test/parser/ts/test-ts-parameter-property8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2ea5cda5aeb0905ca629ef364d9223239a70e02a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private readonly ...rest) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property9-expected.txt b/es2panda/test/parser/ts/test-ts-parameter-property9-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f14f80feb3b71d9817d0a2ed9c5c4fc4ef9927fd
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property9-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A parameter property may not be declared using a binding pattern. [test-ts-parameter-property9.ts:2:17]
diff --git a/es2panda/test/parser/ts/test-ts-parameter-property9.ts b/es2panda/test/parser/ts/test-ts-parameter-property9.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3d7df36d5abaa3d89cd61bebc743d4eb95d0e242
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-parameter-property9.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    constructor(private readonly [bar] = [2]) { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-type-assertion-expected.txt b/es2panda/test/parser/ts/test-ts-type-assertion-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..50d4c5cf5b02ecf1d87b44ab3dd2a3fc5d2830e7
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-assertion-expected.txt
@@ -0,0 +1,301 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 1,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "C",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "foo",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 10
+                },
+                "end": {
+                  "line": 2,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 8
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 8
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "bar",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "TSTypeAssertion",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 12
+                },
+                "end": {
+                  "line": 3,
+                  "column": 18
+                }
+              }
+            },
+            "expression": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 20
+                },
+                "end": {
+                  "line": 3,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 11
+              },
+              "end": {
+                "line": 3,
+                "column": 24
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 24
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "goo",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 8
+              }
+            }
+          },
+          "init": {
+            "type": "TSTypeAssertion",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "C",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 13
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 12
+                },
+                "end": {
+                  "line": 4,
+                  "column": 13
+                }
+              }
+            },
+            "expression": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 15
+                },
+                "end": {
+                  "line": 4,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 11
+              },
+              "end": {
+                "line": 4,
+                "column": 19
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 19
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 19
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 19
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-type-assertion.ts b/es2panda/test/parser/ts/test-ts-type-assertion.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8686a05c1f1384e6f07ab5e09f6d1d022139b0d1
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-assertion.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface C {}
+var foo: any;
+var bar = <string> foo;
+var goo = <C> foo;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..913f9f148806f114459d83328c273b2d8b2155bd
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate-expected.txt
@@ -0,0 +1,5943 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 23
+                },
+                "end": {
+                  "line": 1,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 20
+              },
+              "end": {
+                "line": 1,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 49
+              },
+              "end": {
+                "line": 1,
+                "column": 50
+              }
+            }
+          },
+          "typeAnnotation": null,
+          "asserts": true,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 41
+            },
+            "end": {
+              "line": 1,
+              "column": 50
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 53
+                },
+                "end": {
+                  "line": 1,
+                  "column": 59
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 51
+            },
+            "end": {
+              "line": 1,
+              "column": 61
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 61
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 61
+        },
+        "end": {
+          "line": 1,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var1",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 21
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 2,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 2,
+                            "column": 30
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 13
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 44
+                    }
+                  }
+                },
+                "typeAnnotation": null,
+                "asserts": true,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 11
+                },
+                "end": {
+                  "line": 2,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 24
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 36
+                  }
+                }
+              },
+              "typeAnnotation": null,
+              "asserts": true,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 27
+                },
+                "end": {
+                  "line": 4,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 37
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 24
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 39
+                  }
+                }
+              },
+              "typeAnnotation": null,
+              "asserts": true,
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 27
+                },
+                "end": {
+                  "line": 5,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 40
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 22
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 11
+          },
+          "end": {
+            "line": 3,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 10
+            },
+            "end": {
+              "line": 8,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "asserts",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 35
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 29
+                },
+                "end": {
+                  "line": 8,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 20
+              },
+              "end": {
+                "line": 8,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "asserts",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 47
+              },
+              "end": {
+                "line": 8,
+                "column": 54
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 58
+              },
+              "end": {
+                "line": 8,
+                "column": 64
+              }
+            }
+          },
+          "asserts": false,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 47
+            },
+            "end": {
+              "line": 8,
+              "column": 64
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 67
+                },
+                "end": {
+                  "line": 8,
+                  "column": 73
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 65
+            },
+            "end": {
+              "line": 8,
+              "column": 75
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 8,
+            "column": 75
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 75
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 75
+        },
+        "end": {
+          "line": 8,
+          "column": 76
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var2",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "asserts",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 9,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 9,
+                            "column": 27
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 9,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 9,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 19
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "asserts",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 48
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 52
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 58
+                    }
+                  }
+                },
+                "asserts": false,
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 58
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 11
+                },
+                "end": {
+                  "line": 9,
+                  "column": 58
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 59
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 5
+                },
+                "end": {
+                  "line": 11,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "asserts",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 21
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 12,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 12,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 30
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "asserts",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 40
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 50
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 33
+                },
+                "end": {
+                  "line": 12,
+                  "column": 50
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 51
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "asserts",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 13,
+                                "column": 20
+                              },
+                              "end": {
+                                "line": 13,
+                                "column": 26
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 13,
+                                "column": 29
+                              },
+                              "end": {
+                                "line": 13,
+                                "column": 35
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 13,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 13,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 37
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 37
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "asserts",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 47
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 51
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 55
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 40
+                },
+                "end": {
+                  "line": 13,
+                  "column": 55
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 56
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 22
+          },
+          "end": {
+            "line": 14,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface2",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 11
+          },
+          "end": {
+            "line": 10,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 10
+            },
+            "end": {
+              "line": 16,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "is",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 24
+                },
+                "end": {
+                  "line": 16,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 20
+              },
+              "end": {
+                "line": 16,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "is",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 42
+              },
+              "end": {
+                "line": 16,
+                "column": 44
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 48
+              },
+              "end": {
+                "line": 16,
+                "column": 54
+              }
+            }
+          },
+          "asserts": false,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 42
+            },
+            "end": {
+              "line": 16,
+              "column": 54
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 57
+                },
+                "end": {
+                  "line": 16,
+                  "column": 63
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 55
+            },
+            "end": {
+              "line": 16,
+              "column": 65
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 1
+          },
+          "end": {
+            "line": 16,
+            "column": 65
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 65
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 65
+        },
+        "end": {
+          "line": 16,
+          "column": 66
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var3",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "is",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 22
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 31
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "is",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 36
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 38
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 48
+                    }
+                  }
+                },
+                "asserts": false,
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 36
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 48
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 11
+                },
+                "end": {
+                  "line": 17,
+                  "column": 48
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 5
+                },
+                "end": {
+                  "line": 19,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 8
+                },
+                "end": {
+                  "line": 19,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 5
+              },
+              "end": {
+                "line": 19,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "is",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 20,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 20,
+                          "column": 25
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 25
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 8
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "is",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 28
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 30
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 40
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 28
+                },
+                "end": {
+                  "line": 20,
+                  "column": 40
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 41
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "is",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 21
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 30
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 32
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 32
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 8
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "is",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 37
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 45
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 35
+                },
+                "end": {
+                  "line": 21,
+                  "column": 45
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 46
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 22
+          },
+          "end": {
+            "line": 22,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 11
+          },
+          "end": {
+            "line": 18,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 10
+            },
+            "end": {
+              "line": 24,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 23
+                },
+                "end": {
+                  "line": 24,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 20
+              },
+              "end": {
+                "line": 24,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 41
+              },
+              "end": {
+                "line": 24,
+                "column": 42
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 46
+              },
+              "end": {
+                "line": 24,
+                "column": 52
+              }
+            }
+          },
+          "asserts": false,
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 41
+            },
+            "end": {
+              "line": 24,
+              "column": 52
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 55
+                },
+                "end": {
+                  "line": 24,
+                  "column": 61
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 53
+            },
+            "end": {
+              "line": 24,
+              "column": 63
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 63
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 63
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 63
+        },
+        "end": {
+          "line": 24,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var4",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 21
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 30
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 13
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 36
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 46
+                    }
+                  }
+                },
+                "asserts": false,
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 46
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 11
+                },
+                "end": {
+                  "line": 25,
+                  "column": 46
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 47
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 5
+                },
+                "end": {
+                  "line": 27,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 8
+                },
+                "end": {
+                  "line": 27,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 5
+              },
+              "end": {
+                "line": 27,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 28,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 28,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 28,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 28,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 24
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 27
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 28
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 38
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 27
+                },
+                "end": {
+                  "line": 28,
+                  "column": 38
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 39
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 12
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 20
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 23
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 29
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 31
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 31
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 35
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 43
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 34
+                },
+                "end": {
+                  "line": 29,
+                  "column": 43
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 44
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 22
+          },
+          "end": {
+            "line": 30,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface4",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 26,
+            "column": 11
+          },
+          "end": {
+            "line": 26,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function5",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 10
+            },
+            "end": {
+              "line": 32,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 23
+                },
+                "end": {
+                  "line": 32,
+                  "column": 38
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 20
+              },
+              "end": {
+                "line": 32,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "a",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 49
+              },
+              "end": {
+                "line": 32,
+                "column": 50
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 32,
+                "column": 54
+              },
+              "end": {
+                "line": 32,
+                "column": 60
+              }
+            }
+          },
+          "asserts": true,
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 41
+            },
+            "end": {
+              "line": 32,
+              "column": 60
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 63
+                },
+                "end": {
+                  "line": 32,
+                  "column": 69
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 61
+            },
+            "end": {
+              "line": 32,
+              "column": 71
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 1
+          },
+          "end": {
+            "line": 32,
+            "column": 71
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 71
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 71
+        },
+        "end": {
+          "line": 32,
+          "column": 72
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var5",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 21
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 30
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 33,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 13
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 43
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 44
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 54
+                    }
+                  }
+                },
+                "asserts": true,
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 54
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 11
+                },
+                "end": {
+                  "line": 33,
+                  "column": 54
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 33,
+              "column": 5
+            },
+            "end": {
+              "line": 33,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 1
+        },
+        "end": {
+          "line": 33,
+          "column": 55
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 5
+                },
+                "end": {
+                  "line": 35,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 8
+                },
+                "end": {
+                  "line": 35,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 5
+              },
+              "end": {
+                "line": 35,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 18
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 24
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 36
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 46
+                  }
+                }
+              },
+              "asserts": true,
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 27
+                },
+                "end": {
+                  "line": 36,
+                  "column": 46
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 5
+              },
+              "end": {
+                "line": 36,
+                "column": 47
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "a",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 37,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 37,
+                            "column": 12
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 20
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 23
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 29
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 37,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 37,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 37,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 37,
+                          "column": 31
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 31
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 7
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 43
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 51
+                  }
+                }
+              },
+              "asserts": true,
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 34
+                },
+                "end": {
+                  "line": 37,
+                  "column": 51
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 5
+              },
+              "end": {
+                "line": 37,
+                "column": 52
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 22
+          },
+          "end": {
+            "line": 38,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface5",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 11
+          },
+          "end": {
+            "line": 34,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function6",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 10
+            },
+            "end": {
+              "line": 40,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "asserts",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 40,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 40,
+                      "column": 35
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 40,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 40,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 29
+                },
+                "end": {
+                  "line": 40,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 20
+              },
+              "end": {
+                "line": 40,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "asserts",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 55
+              },
+              "end": {
+                "line": 40,
+                "column": 62
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 40,
+                "column": 66
+              },
+              "end": {
+                "line": 40,
+                "column": 72
+              }
+            }
+          },
+          "asserts": true,
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 47
+            },
+            "end": {
+              "line": 40,
+              "column": 72
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 75
+                },
+                "end": {
+                  "line": 40,
+                  "column": 81
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 73
+            },
+            "end": {
+              "line": 40,
+              "column": 83
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 1
+          },
+          "end": {
+            "line": 40,
+            "column": 83
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 83
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 83
+        },
+        "end": {
+          "line": 40,
+          "column": 84
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var6",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "asserts",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 27
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 19
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "asserts",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 49
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 56
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 66
+                    }
+                  }
+                },
+                "asserts": true,
+                "loc": {
+                  "start": {
+                    "line": 41,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 41,
+                    "column": 66
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 11
+                },
+                "end": {
+                  "line": 41,
+                  "column": 66
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 5
+              },
+              "end": {
+                "line": 41,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 5
+            },
+            "end": {
+              "line": 41,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 41,
+          "column": 67
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 5
+                },
+                "end": {
+                  "line": 43,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 43,
+                  "column": 8
+                },
+                "end": {
+                  "line": 43,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 43,
+                "column": 5
+              },
+              "end": {
+                "line": 43,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "asserts",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 44,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 44,
+                          "column": 21
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 44,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 44,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 44,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 30
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 44,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "asserts",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 44,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 48
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 44,
+                    "column": 52
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 58
+                  }
+                }
+              },
+              "asserts": true,
+              "loc": {
+                "start": {
+                  "line": 44,
+                  "column": 33
+                },
+                "end": {
+                  "line": 44,
+                  "column": 58
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 44,
+                "column": 5
+              },
+              "end": {
+                "line": 44,
+                "column": 59
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "asserts",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 45,
+                                "column": 20
+                              },
+                              "end": {
+                                "line": 45,
+                                "column": 26
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 45,
+                                "column": 29
+                              },
+                              "end": {
+                                "line": 45,
+                                "column": 35
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 45,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 45,
+                          "column": 37
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 37
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 13
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "asserts",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 48
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 55
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 59
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 63
+                  }
+                }
+              },
+              "asserts": true,
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 40
+                },
+                "end": {
+                  "line": 45,
+                  "column": 63
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 64
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 22
+          },
+          "end": {
+            "line": 46,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface6",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 42,
+            "column": 11
+          },
+          "end": {
+            "line": 42,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 42,
+          "column": 1
+        },
+        "end": {
+          "line": 46,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "is",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 48,
+            "column": 6
+          },
+          "end": {
+            "line": 48,
+            "column": 8
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSStringKeyword",
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 11
+              },
+              "end": {
+                "line": 48,
+                "column": 17
+              }
+            }
+          },
+          {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 20
+              },
+              "end": {
+                "line": 48,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "TSBooleanKeyword",
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 29
+              },
+              "end": {
+                "line": 48,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 48,
+            "column": 11
+          },
+          "end": {
+            "line": 48,
+            "column": 36
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 48,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 48,
+          "column": 36
+        },
+        "end": {
+          "line": 48,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function7",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 10
+            },
+            "end": {
+              "line": 50,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "is",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 50,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 50,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 50,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 50,
+                      "column": 39
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "is",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 50,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 50,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 50,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 50,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 24
+                },
+                "end": {
+                  "line": 50,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 20
+              },
+              "end": {
+                "line": 50,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "is",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 47
+              },
+              "end": {
+                "line": 50,
+                "column": 49
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "is",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 53
+                },
+                "end": {
+                  "line": 50,
+                  "column": 55
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 53
+              },
+              "end": {
+                "line": 50,
+                "column": 55
+              }
+            }
+          },
+          "asserts": false,
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 47
+            },
+            "end": {
+              "line": 50,
+              "column": 55
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 58
+                },
+                "end": {
+                  "line": 50,
+                  "column": 64
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 56
+            },
+            "end": {
+              "line": 50,
+              "column": 66
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 50,
+            "column": 1
+          },
+          "end": {
+            "line": 50,
+            "column": 66
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 50,
+          "column": 66
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 66
+        },
+        "end": {
+          "line": 50,
+          "column": 67
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var7",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "is",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 51,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 51,
+                            "column": 22
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 51,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 51,
+                            "column": 31
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSTypeReference",
+                        "typeName": {
+                          "type": "Identifier",
+                          "name": "is",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 51,
+                              "column": 34
+                            },
+                            "end": {
+                              "line": 51,
+                              "column": 36
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 51,
+                            "column": 34
+                          },
+                          "end": {
+                            "line": 51,
+                            "column": 36
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 51,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 51,
+                        "column": 36
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 51,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 51,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "is",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 51,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 51,
+                      "column": 43
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "is",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 51,
+                        "column": 47
+                      },
+                      "end": {
+                        "line": 51,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 51,
+                      "column": 47
+                    },
+                    "end": {
+                      "line": 51,
+                      "column": 49
+                    }
+                  }
+                },
+                "asserts": false,
+                "loc": {
+                  "start": {
+                    "line": 51,
+                    "column": 41
+                  },
+                  "end": {
+                    "line": 51,
+                    "column": 49
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 51,
+                  "column": 11
+                },
+                "end": {
+                  "line": 51,
+                  "column": 49
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 51,
+                "column": 5
+              },
+              "end": {
+                "line": 51,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 51,
+              "column": 5
+            },
+            "end": {
+              "line": 51,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 51,
+          "column": 1
+        },
+        "end": {
+          "line": 51,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "is",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 25
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "is",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 53,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 53,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 30
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 30
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 8
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "is",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 35
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "is",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 41
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 41
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 33
+                },
+                "end": {
+                  "line": 53,
+                  "column": 41
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 5
+              },
+              "end": {
+                "line": 53,
+                "column": 42
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 22
+          },
+          "end": {
+            "line": 54,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface7",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 11
+          },
+          "end": {
+            "line": 52,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 52,
+          "column": 1
+        },
+        "end": {
+          "line": 54,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function8",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 10
+            },
+            "end": {
+              "line": 56,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "string",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 56,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 56,
+                      "column": 34
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 56,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 56,
+                      "column": 43
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "is",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 56,
+                        "column": 46
+                      },
+                      "end": {
+                        "line": 56,
+                        "column": 48
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 56,
+                      "column": 46
+                    },
+                    "end": {
+                      "line": 56,
+                      "column": 48
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 28
+                },
+                "end": {
+                  "line": 56,
+                  "column": 48
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 56,
+                "column": 20
+              },
+              "end": {
+                "line": 56,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "string",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 56,
+                "column": 51
+              },
+              "end": {
+                "line": 56,
+                "column": 57
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 56,
+                "column": 61
+              },
+              "end": {
+                "line": 56,
+                "column": 67
+              }
+            }
+          },
+          "asserts": false,
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 51
+            },
+            "end": {
+              "line": 56,
+              "column": 67
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": null,
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 70
+                },
+                "end": {
+                  "line": 56,
+                  "column": 76
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 68
+            },
+            "end": {
+              "line": 56,
+              "column": 78
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 56,
+            "column": 1
+          },
+          "end": {
+            "line": 56,
+            "column": 78
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 56,
+          "column": 1
+        },
+        "end": {
+          "line": 56,
+          "column": 78
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 56,
+          "column": 78
+        },
+        "end": {
+          "line": 56,
+          "column": 79
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "var8",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "string",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 57,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 57,
+                            "column": 26
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 57,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 57,
+                            "column": 35
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSTypeReference",
+                        "typeName": {
+                          "type": "Identifier",
+                          "name": "is",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 57,
+                              "column": 38
+                            },
+                            "end": {
+                              "line": 57,
+                              "column": 40
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 57,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 57,
+                            "column": 40
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 57,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 57,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 57,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 57,
+                      "column": 18
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypePredicate",
+                "parameterName": {
+                  "type": "Identifier",
+                  "name": "string",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 57,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 57,
+                      "column": 51
+                    }
+                  }
+                },
+                "typeAnnotation": {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 57,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 57,
+                      "column": 61
+                    }
+                  }
+                },
+                "asserts": false,
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 61
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 57,
+                  "column": 11
+                },
+                "end": {
+                  "line": 57,
+                  "column": 61
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 57,
+                "column": 5
+              },
+              "end": {
+                "line": 57,
+                "column": 9
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 5
+            },
+            "end": {
+              "line": 57,
+              "column": 9
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 57,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 5
+                },
+                "end": {
+                  "line": 59,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "is",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 59,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 59,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 59,
+                  "column": 8
+                },
+                "end": {
+                  "line": 59,
+                  "column": 10
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 59,
+                "column": 5
+              },
+              "end": {
+                "line": 59,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "string",
+                "typeAnnotation": {
+                  "type": "TSUnionType",
+                  "types": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 60,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 60,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 60,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 60,
+                          "column": 29
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "is",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 60,
+                            "column": 32
+                          },
+                          "end": {
+                            "line": 60,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 60,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 60,
+                          "column": 34
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 60,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 60,
+                      "column": 34
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 12
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "string",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 43
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 60,
+                    "column": 47
+                  },
+                  "end": {
+                    "line": 60,
+                    "column": 53
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 60,
+                  "column": 37
+                },
+                "end": {
+                  "line": 60,
+                  "column": 53
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 60,
+                "column": 5
+              },
+              "end": {
+                "line": 60,
+                "column": 54
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "string",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 61,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 61,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 61,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 61,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 61,
+                                "column": 28
+                              },
+                              "end": {
+                                "line": 61,
+                                "column": 34
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSTypeReference",
+                            "typeName": {
+                              "type": "Identifier",
+                              "name": "is",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 61,
+                                  "column": 37
+                                },
+                                "end": {
+                                  "line": 61,
+                                  "column": 39
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 61,
+                                "column": 37
+                              },
+                              "end": {
+                                "line": 61,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 61,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 61,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 61,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 61,
+                          "column": 41
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 61,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 61,
+                      "column": 41
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 61,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 61,
+                    "column": 12
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "Identifier",
+                "name": "string",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 61,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 61,
+                    "column": 50
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 61,
+                    "column": 54
+                  },
+                  "end": {
+                    "line": 61,
+                    "column": 58
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 61,
+                  "column": 44
+                },
+                "end": {
+                  "line": 61,
+                  "column": 58
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 61,
+                "column": 5
+              },
+              "end": {
+                "line": 61,
+                "column": 59
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 58,
+            "column": 22
+          },
+          "end": {
+            "line": 62,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface8",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 58,
+            "column": 11
+          },
+          "end": {
+            "line": 58,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 62,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 5
+                },
+                "end": {
+                  "line": 65,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "is",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 65,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 65,
+                    "column": 10
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 65,
+                  "column": 8
+                },
+                "end": {
+                  "line": 65,
+                  "column": 10
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 65,
+                "column": 5
+              },
+              "end": {
+                "line": 65,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [
+              {
+                "type": "Identifier",
+                "name": "string",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 66,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 66,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 66,
+                                "column": 19
+                              },
+                              "end": {
+                                "line": 66,
+                                "column": 25
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 66,
+                                "column": 28
+                              },
+                              "end": {
+                                "line": 66,
+                                "column": 34
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSTypeReference",
+                            "typeName": {
+                              "type": "Identifier",
+                              "name": "is",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 66,
+                                  "column": 37
+                                },
+                                "end": {
+                                  "line": 66,
+                                  "column": 39
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 66,
+                                "column": 37
+                              },
+                              "end": {
+                                "line": 66,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 66,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 66,
+                            "column": 39
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 66,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 66,
+                          "column": 41
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 66,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 66,
+                      "column": 41
+                    }
+                  }
+                },
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 66,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 66,
+                    "column": 12
+                  }
+                }
+              }
+            ],
+            "returnType": {
+              "type": "TSTypePredicate",
+              "parameterName": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 66,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 66,
+                    "column": 48
+                  }
+                }
+              },
+              "typeAnnotation": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 66,
+                    "column": 52
+                  },
+                  "end": {
+                    "line": 66,
+                    "column": 56
+                  }
+                }
+              },
+              "asserts": false,
+              "loc": {
+                "start": {
+                  "line": 66,
+                  "column": 44
+                },
+                "end": {
+                  "line": 66,
+                  "column": 56
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 66,
+                "column": 5
+              },
+              "end": {
+                "line": 66,
+                "column": 57
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 22
+          },
+          "end": {
+            "line": 67,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Interface9",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 64,
+            "column": 11
+          },
+          "end": {
+            "line": 64,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 64,
+          "column": 1
+        },
+        "end": {
+          "line": 67,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 67,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate.ts b/es2panda/test/parser/ts/test-ts-type-predicate.ts
new file mode 100644
index 0000000000000000000000000000000000000000..db5b78f8ea59a09b473cd1538d0aa359f37c353b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate.ts
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function function1(a: number | string): asserts a { return };
+var var1: (a: number | string) => asserts a;
+interface Interface1 {
+    (a: number | string): asserts a;
+    (a: number | string): asserts this;
+}
+
+function function2(asserts: number | string): asserts is number { return };
+var var2: (asserts: number | string) => asserts is number;
+interface Interface2 {
+    a: number;
+    (asserts: number | string): asserts is number;
+    (asserts: { a: number | string }): asserts is this;
+}
+
+function function3(is: number | string): is is number { return };
+var var3: (is: number | string) => is is number;
+interface Interface3 {
+    a: number;
+    (is: number | string): is is number;
+    (is: { a: number | string }): is is this;
+}
+
+function function4(a: number | string): a is number { return };
+var var4: (a: number | string) => a is number;
+interface Interface4 {
+    a: number;
+    (a: number | string): a is number;
+    (a: { a: number | string }): a is this;
+}
+
+function function5(a: number | string): asserts a is number { return };
+var var5: (a: number | string) => asserts a is number;
+interface Interface5 {
+    a: number;
+    (a: number | string): asserts a is number;
+    (a: { a: number | string }): asserts a is this;
+}
+
+function function6(asserts: number | string): asserts asserts is number { return };
+var var6: (asserts: number | string) => asserts asserts is number;
+interface Interface6 {
+    a: number;
+    (asserts: number | string): asserts asserts is number;
+    (asserts: { a: number | string }): asserts asserts is this;
+}
+
+type is = string | number | boolean;
+
+function function7(is: number | string | is): is is is { return };
+var var7: (is: number | string | is) => is is is;
+interface Interface7 {
+    (is: number | string | is): is is is;
+}
+
+function function8(string: number | string | is): string is number { return };
+var var8: (string: number | string | is) => string is number;
+interface Interface8 {
+    a: is;
+    (string: number | string | is): string is number;
+    (string: { a: number | string | is }): string is this;
+}
+
+interface Interface9 {
+    a: is;
+    (string: { a: number | string | is }): this is this;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate1-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1a91469499f5dff16ed3f0e1781df78bea051956
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate1-expected.txt
@@ -0,0 +1,205 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSDeclareFunction",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "function1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 19
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "is",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 24
+                },
+                "end": {
+                  "line": 1,
+                  "column": 39
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 20
+              },
+              "end": {
+                "line": 1,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypePredicate",
+          "parameterName": {
+            "type": "Identifier",
+            "name": "asserts",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 42
+              },
+              "end": {
+                "line": 1,
+                "column": 49
+              }
+            }
+          },
+          "typeAnnotation": {
+            "type": "TSTypeLiteral",
+            "members": [
+              {
+                "type": "TSPropertySignature",
+                "computed": false,
+                "optional": false,
+                "readonly": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "return",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 61
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 55
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 63
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 53
+              },
+              "end": {
+                "line": 1,
+                "column": 63
+              }
+            }
+          },
+          "asserts": false,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 42
+            },
+            "end": {
+              "line": 1,
+              "column": 63
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 64
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 63
+        },
+        "end": {
+          "line": 1,
+          "column": 64
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 1,
+      "column": 64
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate1.ts b/es2panda/test/parser/ts/test-ts-type-predicate1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ec4ca9acbc6964a21ac657238b4b3139f42f2918
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function function1(is: number | string): asserts is { return };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate2-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e839f3dec213182d8e6946aeed9f8c45ba7f963a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-ts-type-predicate2.ts:1:46]
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate2.ts b/es2panda/test/parser/ts/test-ts-type-predicate2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ea1686930770855d79a6404c42ebf909c77eed39
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var var1: (is: number | string) => asserts is;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate3-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6a5c9afc5d4548c205884a51e9a692c25777ed8b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-type-predicate3.ts:1:63]
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate3.ts b/es2panda/test/parser/ts/test-ts-type-predicate3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dae4c431d98203fb34c0de7b32792b4fef155635
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function function1(is: number | string): asserts is is number { return };
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate4-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..42c58e288ea8d77cbd7f3b3fbb5dccca3b2cd917
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-type-predicate4.ts:1:50]
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate4.ts b/es2panda/test/parser/ts/test-ts-type-predicate4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..927e29e7beb40a327d9dee95141eb3ba8115ac85
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var var1: (is: number | string) => asserts is is number;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate5-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4064e85182f93d2671094070a7eb7e8df6fd9356
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-type-predicate5.ts:1:68]
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate5.ts b/es2panda/test/parser/ts/test-ts-type-predicate5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eaf51510a96daa9bfc028f3fe43b92caf2156346
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate5.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function function1(is: number | string): asserts (number | string) { return };
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate6-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d07417cc4ade75fff550d24e306b8abf7bcc56bd
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-type-predicate6.ts:1:44]
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate6.ts b/es2panda/test/parser/ts/test-ts-type-predicate6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bfbdbca439236f62f7edb65185c3c4f3d8ddcced
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate6.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var var1: (is: number | string) => asserts (number | string);
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate7-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..96e1e5070be4da0281f53e8601f9082ba2b02da4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-type-predicate7.ts:1:63]
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate7.ts b/es2panda/test/parser/ts/test-ts-type-predicate7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..15a6b8a0e8b8dfad4344373aad5b484c83c6724a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate7.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function function1(is: number | string): (number | string) is number { return };
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate8-expected.txt b/es2panda/test/parser/ts/test-ts-type-predicate8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d6b1165a70822d814f3eae6bb560ea07701f7e0b
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate8-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token [test-ts-type-predicate8.ts:1:54]
diff --git a/es2panda/test/parser/ts/test-ts-type-predicate8.ts b/es2panda/test/parser/ts/test-ts-type-predicate8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..63aa16dc47e8acc915052edef115a92281572a09
--- /dev/null
+++ b/es2panda/test/parser/ts/test-ts-type-predicate8.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var var1: (is: number | string) => (number | string) is number;
diff --git a/es2panda/test/parser/ts/test-tuple-type-expected.txt b/es2panda/test/parser/ts/test-tuple-type-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ac5a60e951a1a0a433b07255de75ea7d055a9235
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type-expected.txt
@@ -0,0 +1,919 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 19
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 30
+                    }
+                  }
+                },
+                {
+                  "type": "TSNamedTupleMember",
+                  "elementType": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSParenthesizedType",
+                      "typeAnnotation": {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSBooleanKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 35
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 42
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSVoidKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 45
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 49
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 49
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 50
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 52
+                      }
+                    }
+                  },
+                  "label": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 53
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 53
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 54
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 24
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 10
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 20
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNamedTupleMember",
+                      "elementType": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 30
+                          }
+                        }
+                      },
+                      "label": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 31
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 32
+                    }
+                  }
+                },
+                {
+                  "type": "TSFunctionType",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSVoidKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 41
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSTupleType",
+                        "elementTypes": [
+                          {
+                            "type": "TSBooleanKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 3,
+                                "column": 47
+                              },
+                              "end": {
+                                "line": 3,
+                                "column": 55
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSBooleanKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 3,
+                                "column": 56
+                              },
+                              "end": {
+                                "line": 3,
+                                "column": 64
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 64
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 43
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 44
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSUndefinedKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 69
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 78
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 79
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 79
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSTupleType",
+                      "elementTypes": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 18
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 4,
+                              "column": 19
+                            },
+                            "end": {
+                              "line": 4,
+                              "column": 26
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 27
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 36
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 43
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 52
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 53
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 60
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 60
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "A",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "typeParameters": {
+                    "type": "TSTypeParameterInstantiation",
+                    "params": [
+                      {
+                        "type": "TSTypeReference",
+                        "typeName": {
+                          "type": "Identifier",
+                          "name": "T",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 12
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 11
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 12
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 14
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 14
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-tuple-type.ts b/es2panda/test/parser/ts/test-tuple-type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..180ce4a82ef99b0a9a639ef2726c496ebbfc3ee8
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [a: number, b: string, c: (boolean | void)[]];
+var b: [string, string, string];
+var c: [[a: number, b: string], (a: void, b: [boolean, boolean]) => undefined]
+var d: [[[number, number], number, number], number, number]
+var e: [A<T>]
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-tuple-type1-expected.txt b/es2panda/test/parser/ts/test-tuple-type1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5fb56e938729e111ee07bfaaa0729a2672bfd2ed
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ',' expected. [test-tuple-type1.ts:1:19]
diff --git a/es2panda/test/parser/ts/test-tuple-type1.ts b/es2panda/test/parser/ts/test-tuple-type1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0a71d68b3f416f67561e4af3cff3605c46211a44
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [a: number string]
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-tuple-type2-expected.txt b/es2panda/test/parser/ts/test-tuple-type2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..69dea6a9b0f1c95a156f2667b74802fd09d910c4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Tuple members must all have names or all not have names [test-tuple-type2.ts:1:17]
diff --git a/es2panda/test/parser/ts/test-tuple-type2.ts b/es2panda/test/parser/ts/test-tuple-type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..17dcf7109de2bc7c9a9f806767d3dbbc5d84b09a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [number, a: string]
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-tuple-type3-expected.txt b/es2panda/test/parser/ts/test-tuple-type3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eba61c04003c179d80c611e7a97c3bfd4fba333c
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-tuple-type3.ts:1:9]
diff --git a/es2panda/test/parser/ts/test-tuple-type3.ts b/es2panda/test/parser/ts/test-tuple-type3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e4af3e32fb7343bb74b435ef4f200cb1396503f5
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [?number]
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-tuple-type4-expected.txt b/es2panda/test/parser/ts/test-tuple-type4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8d27f5e17419b2d3d4186d493c723e3e6523acca
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A required element cannot follow an optional element [test-tuple-type4.ts:1:22]
diff --git a/es2panda/test/parser/ts/test-tuple-type4.ts b/es2panda/test/parser/ts/test-tuple-type4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8afce7388f7b6b98d6b63fba1e2bcd0ea8653d17
--- /dev/null
+++ b/es2panda/test/parser/ts/test-tuple-type4.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: [a?: number, b: string]
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-alias-expected.txt b/es2panda/test/parser/ts/test-type-alias-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ca007f2c7459010d8d5950c1df4ec914e35b3269
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias-expected.txt
@@ -0,0 +1,502 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "foo",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 6
+          },
+          "end": {
+            "line": 1,
+            "column": 9
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 12
+              },
+              "end": {
+                "line": 1,
+                "column": 18
+              }
+            }
+          },
+          {
+            "type": "TSStringKeyword",
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 21
+              },
+              "end": {
+                "line": 1,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 12
+          },
+          "end": {
+            "line": 1,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 27
+        },
+        "end": {
+          "line": 1,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "bar",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 6
+          },
+          "end": {
+            "line": 2,
+            "column": 9
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 12
+                },
+                "end": {
+                  "line": 2,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 12
+              },
+              "end": {
+                "line": 2,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSParenthesizedType",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 21
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 34
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 31
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSVoidKeyword",
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 49
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 19
+                },
+                "end": {
+                  "line": 2,
+                  "column": 49
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 18
+              },
+              "end": {
+                "line": 2,
+                "column": 50
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 12
+          },
+          "end": {
+            "line": 2,
+            "column": 50
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 50
+        },
+        "end": {
+          "line": 2,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "baz",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 6
+          },
+          "end": {
+            "line": 3,
+            "column": 9
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 12
+                },
+                "end": {
+                  "line": 3,
+                  "column": 15
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 12
+              },
+              "end": {
+                "line": 3,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSArrayType",
+            "elementType": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 3,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 3,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 18
+                },
+                "end": {
+                  "line": 3,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 18
+              },
+              "end": {
+                "line": 3,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "TSArrayType",
+            "elementType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 26
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 26
+              },
+              "end": {
+                "line": 3,
+                "column": 34
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 12
+          },
+          "end": {
+            "line": 3,
+            "column": 34
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 34
+        },
+        "end": {
+          "line": 3,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "baz",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 12
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 12
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-type-alias.ts b/es2panda/test/parser/ts/test-type-alias.ts
new file mode 100644
index 0000000000000000000000000000000000000000..491accecbedb3ca10178cebadf577530e4777b25
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type foo = number | string;
+type bar = foo | ((a: number, b: string) => void);
+type baz = foo | bar[] | number[];
+var a: baz;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-alias1-expected.txt b/es2panda/test/parser/ts/test-type-alias1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6df5f20adfa72a850c6a1926070e23e3b83521ba
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Identifier expected [test-type-alias1.ts:1:6]
diff --git a/es2panda/test/parser/ts/test-type-alias1.ts b/es2panda/test/parser/ts/test-type-alias1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d2b61be22fa996471f5780ede20912248bb8ee77
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type 5 = number;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-alias2-expected.txt b/es2panda/test/parser/ts/test-type-alias2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ae531f60587e7cb7c1fdc7c52ec03a7dc281cf66
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: '=' expected [test-type-alias2.ts:1:10]
diff --git a/es2panda/test/parser/ts/test-type-alias2.ts b/es2panda/test/parser/ts/test-type-alias2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5493c3688337029601f7c18a97f0bdfea8d79ad3
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type bar number;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-alias3-expected.txt b/es2panda/test/parser/ts/test-type-alias3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dc5ba5d594c1dc077b44f9f1dfbf39e9f9ed0bfe
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Type expected [test-type-alias3.ts:1:12]
diff --git a/es2panda/test/parser/ts/test-type-alias3.ts b/es2panda/test/parser/ts/test-type-alias3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..300647141376ac827be1e9f799aa85c11a45ba9d
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-alias3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+type foo = ;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-annotation-expected.txt b/es2panda/test/parser/ts/test-type-annotation-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e216af930f9df9ea07ab98c875c4db7800fe81c2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-annotation-expected.txt
@@ -0,0 +1,4090 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSVoidKeyword",
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSNullKeyword",
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 12
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 6,
+              "column": 5
+            },
+            "end": {
+              "line": 6,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 6,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 13
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "f",
+            "typeAnnotation": {
+              "type": "TSUndefinedKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 8
+                },
+                "end": {
+                  "line": 7,
+                  "column": 17
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 5
+            },
+            "end": {
+              "line": 7,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "g",
+            "typeAnnotation": {
+              "type": "TSUnknownKeyword",
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 8
+                },
+                "end": {
+                  "line": 8,
+                  "column": 15
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 5
+              },
+              "end": {
+                "line": 8,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 5
+            },
+            "end": {
+              "line": 8,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 8,
+          "column": 16
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "h",
+            "typeAnnotation": {
+              "type": "TSNeverKeyword",
+              "loc": {
+                "start": {
+                  "line": 9,
+                  "column": 8
+                },
+                "end": {
+                  "line": 9,
+                  "column": 13
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 9,
+                "column": 5
+              },
+              "end": {
+                "line": 9,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 9,
+              "column": 5
+            },
+            "end": {
+              "line": 9,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 9,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "i",
+            "typeAnnotation": {
+              "type": "TSAnyKeyword",
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 8
+                },
+                "end": {
+                  "line": 10,
+                  "column": 11
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 10,
+                "column": 5
+              },
+              "end": {
+                "line": 10,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 10,
+              "column": 5
+            },
+            "end": {
+              "line": 10,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 12
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "j",
+            "typeAnnotation": {
+              "type": "TSBigIntKeyword",
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 8
+                },
+                "end": {
+                  "line": 11,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 5
+            },
+            "end": {
+              "line": 11,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 1
+        },
+        "end": {
+          "line": 11,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "k",
+            "typeAnnotation": {
+              "type": "TSObjectKeyword",
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 8
+                },
+                "end": {
+                  "line": 12,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 12,
+                "column": 5
+              },
+              "end": {
+                "line": 12,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 12,
+              "column": 5
+            },
+            "end": {
+              "line": 12,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 12,
+          "column": 1
+        },
+        "end": {
+          "line": 12,
+          "column": 15
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "l",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 14
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 8
+                },
+                "end": {
+                  "line": 15,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 15,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 15,
+              "column": 5
+            },
+            "end": {
+              "line": 15,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 15,
+          "column": 1
+        },
+        "end": {
+          "line": 15,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "m",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSArrayType",
+                "elementType": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 14
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 8
+                },
+                "end": {
+                  "line": 16,
+                  "column": 18
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 5
+              },
+              "end": {
+                "line": 16,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 5
+            },
+            "end": {
+              "line": 16,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 19
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "n",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSUnknownKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 17
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSLiteralType",
+                    "literal": {
+                      "type": "BigIntLiteral",
+                      "value": "5n",
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 24
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 8
+                },
+                "end": {
+                  "line": 17,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 5
+            },
+            "end": {
+              "line": 17,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSParenthesizedType",
+                    "typeAnnotation": {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 20,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 20,
+                              "column": 15
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 20,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 20,
+                              "column": 24
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 20,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 34
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 34
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSParenthesizedType",
+                    "typeAnnotation": {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSArrayType",
+                          "elementType": {
+                            "type": "TSParenthesizedType",
+                            "typeAnnotation": {
+                              "type": "TSUnionType",
+                              "types": [
+                                {
+                                  "type": "TSArrayType",
+                                  "elementType": {
+                                    "type": "TSUndefinedKeyword",
+                                    "loc": {
+                                      "start": {
+                                        "line": 20,
+                                        "column": 39
+                                      },
+                                      "end": {
+                                        "line": 20,
+                                        "column": 48
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 20,
+                                      "column": 39
+                                    },
+                                    "end": {
+                                      "line": 20,
+                                      "column": 50
+                                    }
+                                  }
+                                },
+                                {
+                                  "type": "TSUnknownKeyword",
+                                  "loc": {
+                                    "start": {
+                                      "line": 20,
+                                      "column": 53
+                                    },
+                                    "end": {
+                                      "line": 20,
+                                      "column": 60
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 20,
+                                  "column": 39
+                                },
+                                "end": {
+                                  "line": 20,
+                                  "column": 60
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 20,
+                                "column": 38
+                              },
+                              "end": {
+                                "line": 20,
+                                "column": 61
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 20,
+                              "column": 38
+                            },
+                            "end": {
+                              "line": 20,
+                              "column": 63
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSLiteralType",
+                          "literal": {
+                            "type": "StringLiteral",
+                            "value": "foo",
+                            "loc": {
+                              "start": {
+                                "line": 20,
+                                "column": 66
+                              },
+                              "end": {
+                                "line": 20,
+                                "column": 71
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 20,
+                              "column": 66
+                            },
+                            "end": {
+                              "line": 20,
+                              "column": 71
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 20,
+                          "column": 71
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 72
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 74
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 8
+                },
+                "end": {
+                  "line": 20,
+                  "column": 74
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 5
+            },
+            "end": {
+              "line": 20,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 75
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "p",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSParenthesizedType",
+                    "typeAnnotation": {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 15
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 24
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 21,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSParenthesizedType",
+                    "typeAnnotation": {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 37
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 46
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 21,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 49
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 8
+                },
+                "end": {
+                  "line": 21,
+                  "column": 49
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 5
+              },
+              "end": {
+                "line": 21,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 5
+            },
+            "end": {
+              "line": 21,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 50
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "q",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSParenthesizedType",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSParenthesizedType",
+                          "typeAnnotation": {
+                            "type": "TSUnionType",
+                            "types": [
+                              {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 10
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 16
+                                  }
+                                }
+                              },
+                              {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 19
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 25
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 22,
+                                "column": 10
+                              },
+                              "end": {
+                                "line": 22,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 22,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 22,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 22,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 28
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSParenthesizedType",
+                          "typeAnnotation": {
+                            "type": "TSUnionType",
+                            "types": [
+                              {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 32
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 38
+                                  }
+                                }
+                              },
+                              {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 22,
+                                    "column": 41
+                                  },
+                                  "end": {
+                                    "line": 22,
+                                    "column": 47
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 22,
+                                "column": 32
+                              },
+                              "end": {
+                                "line": 22,
+                                "column": 47
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 22,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 22,
+                              "column": 48
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 22,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 50
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 22,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 22,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 51
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 22,
+                      "column": 54
+                    },
+                    "end": {
+                      "line": 22,
+                      "column": 60
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 8
+                },
+                "end": {
+                  "line": 22,
+                  "column": 60
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 5
+              },
+              "end": {
+                "line": 22,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 5
+            },
+            "end": {
+              "line": 22,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "r",
+            "typeAnnotation": {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSParenthesizedType",
+                "typeAnnotation": {
+                  "type": "TSParenthesizedType",
+                  "typeAnnotation": {
+                    "type": "TSParenthesizedType",
+                    "typeAnnotation": {
+                      "type": "TSParenthesizedType",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 25,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 25,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 25,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 25,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 25,
+                  "column": 8
+                },
+                "end": {
+                  "line": 25,
+                  "column": 24
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 25,
+                "column": 5
+              },
+              "end": {
+                "line": 25,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 25,
+              "column": 5
+            },
+            "end": {
+              "line": 25,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 25,
+          "column": 1
+        },
+        "end": {
+          "line": 25,
+          "column": 25
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "s",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSParenthesizedType",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSParenthesizedType",
+                        "typeAnnotation": {
+                          "type": "TSUnionType",
+                          "types": [
+                            {
+                              "type": "TSStringKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 26,
+                                  "column": 10
+                                },
+                                "end": {
+                                  "line": 26,
+                                  "column": 16
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSBooleanKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 26,
+                                  "column": 19
+                                },
+                                "end": {
+                                  "line": 26,
+                                  "column": 26
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 26,
+                              "column": 10
+                            },
+                            "end": {
+                              "line": 26,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 26,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 27
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSParenthesizedType",
+                        "typeAnnotation": {
+                          "type": "TSUnionType",
+                          "types": [
+                            {
+                              "type": "TSLiteralType",
+                              "literal": {
+                                "type": "NumberLiteral",
+                                "value": 5,
+                                "loc": {
+                                  "start": {
+                                    "line": 26,
+                                    "column": 31
+                                  },
+                                  "end": {
+                                    "line": 26,
+                                    "column": 32
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 26,
+                                  "column": 31
+                                },
+                                "end": {
+                                  "line": 26,
+                                  "column": 32
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSLiteralType",
+                              "literal": {
+                                "type": "BooleanLiteral",
+                                "value": true,
+                                "loc": {
+                                  "start": {
+                                    "line": 26,
+                                    "column": 35
+                                  },
+                                  "end": {
+                                    "line": 26,
+                                    "column": 39
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 26,
+                                  "column": 35
+                                },
+                                "end": {
+                                  "line": 26,
+                                  "column": 39
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 26,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 26,
+                              "column": 39
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 26,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 40
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 41
+                    }
+                  }
+                },
+                {
+                  "type": "TSParenthesizedType",
+                  "typeAnnotation": {
+                    "type": "TSVoidKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 50
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 26,
+                  "column": 8
+                },
+                "end": {
+                  "line": 26,
+                  "column": 50
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 26,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 5
+            },
+            "end": {
+              "line": 26,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 26,
+          "column": 51
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func1",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 44
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 12
+                },
+                "end": {
+                  "line": 29,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 5
+            },
+            "end": {
+              "line": 29,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 45
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func2",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 16
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 16
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 24
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 33
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSLiteralType",
+                    "literal": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 40
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 35
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 36
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 51
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 30,
+                        "column": 60
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 45
+                  },
+                  "end": {
+                    "line": 30,
+                    "column": 60
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 30,
+                  "column": 12
+                },
+                "end": {
+                  "line": 30,
+                  "column": 60
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 30,
+                "column": 5
+              },
+              "end": {
+                "line": 30,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 30,
+              "column": 5
+            },
+            "end": {
+              "line": 30,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 30,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 61
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "func3",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "f",
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 31,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 31,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 31,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 31,
+                            "column": 18
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 31,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 31,
+                              "column": 37
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 31,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 31,
+                            "column": 29
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 31,
+                            "column": 42
+                          },
+                          "end": {
+                            "line": 31,
+                            "column": 48
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 50
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 16
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 14
+                    }
+                  }
+                },
+                {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 53
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 54
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 56
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 57
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 60
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 66
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 60
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 68
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 52
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 58
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSFunctionType",
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 77
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 83
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 74
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 75
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSBooleanKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 31,
+                          "column": 88
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 95
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 85
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 86
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 31,
+                        "column": 100
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 104
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 100
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 104
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 73
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 104
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 12
+                },
+                "end": {
+                  "line": 31,
+                  "column": 104
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 5
+              },
+              "end": {
+                "line": 31,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 31,
+              "column": 5
+            },
+            "end": {
+              "line": 31,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 31,
+          "column": 1
+        },
+        "end": {
+          "line": 31,
+          "column": 105
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "ctor1",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 34,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 29
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 42
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 48
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 12
+                },
+                "end": {
+                  "line": 34,
+                  "column": 48
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 5
+              },
+              "end": {
+                "line": 34,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 5
+            },
+            "end": {
+              "line": 34,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 49
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "ctor2",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 35,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 35,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 28
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 37
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 37
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSLiteralType",
+                    "literal": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 43
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 44
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 43
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 35,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 40
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 49
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 55
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 35,
+                        "column": 58
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 64
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 35,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 64
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 35,
+                  "column": 12
+                },
+                "end": {
+                  "line": 35,
+                  "column": 64
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 35,
+                "column": 5
+              },
+              "end": {
+                "line": 35,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 35,
+              "column": 5
+            },
+            "end": {
+              "line": 35,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 35,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 65
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "ctor3",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "f",
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 36,
+                              "column": 24
+                            },
+                            "end": {
+                              "line": 36,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 36,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 36,
+                            "column": 22
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 36,
+                              "column": 35
+                            },
+                            "end": {
+                              "line": 36,
+                              "column": 41
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 36,
+                            "column": 32
+                          },
+                          "end": {
+                            "line": 36,
+                            "column": 33
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 36,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 36,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 54
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 36,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 36,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 18
+                    }
+                  }
+                },
+                {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 58
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 60
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 61
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 64
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 70
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 36,
+                        "column": 64
+                      },
+                      "end": {
+                        "line": 36,
+                        "column": 72
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 56
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSFunctionType",
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 81
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 87
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 36,
+                        "column": 78
+                      },
+                      "end": {
+                        "line": 36,
+                        "column": 79
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSBooleanKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 92
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 99
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 36,
+                        "column": 89
+                      },
+                      "end": {
+                        "line": 36,
+                        "column": 90
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 36,
+                        "column": 104
+                      },
+                      "end": {
+                        "line": 36,
+                        "column": 108
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 104
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 108
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 77
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 108
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 12
+                },
+                "end": {
+                  "line": 36,
+                  "column": 108
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 5
+              },
+              "end": {
+                "line": 36,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 5
+            },
+            "end": {
+              "line": 36,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 109
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "ctor4",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 37,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 37,
+                        "column": 35
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 37,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 37,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 38
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 51
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 57
+                  }
+                }
+              },
+              "abstract": true,
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 12
+                },
+                "end": {
+                  "line": 37,
+                  "column": 57
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 5
+              },
+              "end": {
+                "line": 37,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 5
+            },
+            "end": {
+              "line": 37,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 37,
+          "column": 58
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "ctor5",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 38,
+                              "column": 29
+                            },
+                            "end": {
+                              "line": 38,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 38,
+                            "column": 29
+                          },
+                          "end": {
+                            "line": 38,
+                            "column": 37
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 38,
+                            "column": 40
+                          },
+                          "end": {
+                            "line": 38,
+                            "column": 46
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 38,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 38,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSLiteralType",
+                    "literal": {
+                      "type": "NumberLiteral",
+                      "value": 5,
+                      "loc": {
+                        "start": {
+                          "line": 38,
+                          "column": 52
+                        },
+                        "end": {
+                          "line": 38,
+                          "column": 53
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 38,
+                        "column": 52
+                      },
+                      "end": {
+                        "line": 38,
+                        "column": 53
+                      }
+                    }
+                  },
+                  "optional": true,
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 48
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 49
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSUnionType",
+                "types": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 38,
+                        "column": 58
+                      },
+                      "end": {
+                        "line": 38,
+                        "column": 64
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 38,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 38,
+                        "column": 73
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 38,
+                    "column": 58
+                  },
+                  "end": {
+                    "line": 38,
+                    "column": 73
+                  }
+                }
+              },
+              "abstract": true,
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 12
+                },
+                "end": {
+                  "line": 38,
+                  "column": 73
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 5
+              },
+              "end": {
+                "line": 38,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 5
+            },
+            "end": {
+              "line": 38,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 74
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "ctor6",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "f",
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 39,
+                              "column": 33
+                            },
+                            "end": {
+                              "line": 39,
+                              "column": 39
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 39,
+                            "column": 30
+                          },
+                          "end": {
+                            "line": 39,
+                            "column": 31
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 39,
+                              "column": 44
+                            },
+                            "end": {
+                              "line": 39,
+                              "column": 50
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 39,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 39,
+                            "column": 42
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 39,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 39,
+                            "column": 61
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 39,
+                          "column": 55
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 63
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 39,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 39,
+                        "column": 63
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 39,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 39,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "ArrayPattern",
+                  "elements": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 39,
+                          "column": 66
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 67
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 39,
+                          "column": 69
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 70
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSArrayType",
+                    "elementType": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 39,
+                          "column": 73
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 79
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 39,
+                        "column": 73
+                      },
+                      "end": {
+                        "line": 39,
+                        "column": 81
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 39,
+                      "column": 65
+                    },
+                    "end": {
+                      "line": 39,
+                      "column": 71
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSFunctionType",
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 39,
+                          "column": 90
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 96
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 39,
+                        "column": 87
+                      },
+                      "end": {
+                        "line": 39,
+                        "column": 88
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSBooleanKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 39,
+                          "column": 101
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 108
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 39,
+                        "column": 98
+                      },
+                      "end": {
+                        "line": 39,
+                        "column": 99
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "BooleanLiteral",
+                    "value": true,
+                    "loc": {
+                      "start": {
+                        "line": 39,
+                        "column": 113
+                      },
+                      "end": {
+                        "line": 39,
+                        "column": 117
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 39,
+                      "column": 113
+                    },
+                    "end": {
+                      "line": 39,
+                      "column": 117
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 39,
+                    "column": 86
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 117
+                  }
+                }
+              },
+              "abstract": true,
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 12
+                },
+                "end": {
+                  "line": 39,
+                  "column": 117
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 5
+              },
+              "end": {
+                "line": 39,
+                "column": 10
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 39,
+              "column": 5
+            },
+            "end": {
+              "line": 39,
+              "column": 10
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 39,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 118
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 39,
+      "column": 118
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-type-annotation.ts b/es2panda/test/parser/ts/test-type-annotation.ts
new file mode 100644
index 0000000000000000000000000000000000000000..42d34c24d0c24ac0f885fccc703bb88cfb037c36
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-annotation.ts
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+// Test basic types
+var a: number;
+var b: string;
+var c: boolean;
+var d: void;
+var e: null;
+var f: undefined;
+var g: unknown;
+var h: never;
+var i: any;
+var j: bigint;
+var k: object;
+
+// Test array type
+var l: number[];
+var m: string[][];
+var n: unknown[] | 5n[];
+
+// Test union type
+var o: (number | string)[] | true | ((undefined[] | unknown)[] | "foo")[];
+var p: (number | string)[] | (number | string)[];
+var q: ((number | number)[] | (number | number)[]) | string;
+
+// Test parenthesized type
+var r: ((((number))))[];
+var s: ((string | boolean) | (5 | true)) | (void);
+
+// Test function type
+var func1: (a: number, b: string) => number;
+var func2: (a: number[] | string, b?: 5) => number | string;
+var func3: (f: (a: number, b: string) => number[], [a, b]: number[]) => (a: number, b: boolean) => true;
+
+// Test constructor type
+var ctor1: new (a: number, b: string) => number;
+var ctor2: new (a: number[] | string, b?: 5) => number | string;
+var ctor3: new (f: (a: number, b: string) => number[], [a, b]: number[]) => (a: number, b: boolean) => true;
+var ctor4: abstract new (a: number, b: string) => number;
+var ctor5: abstract new (a: number[] | string, b?: 5) => number | string;
+var ctor6: abstract new (f: (a: number, b: string) => number[], [a, b]: number[]) => (a: number, b: boolean) => true;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-literal-expected.txt b/es2panda/test/parser/ts/test-type-literal-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7ab3d3f7771889ed173667b42bb6042e6b7b1ee4
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal-expected.txt
@@ -0,0 +1,1010 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSConstructSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 15
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 28
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 25
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 26
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 46
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 48
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 54
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 55
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": true,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 57
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 60
+                        }
+                      }
+                    },
+                    {
+                      "type": "ArrayPattern",
+                      "elements": [
+                        {
+                          "type": "Identifier",
+                          "name": "c",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 63
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 64
+                            }
+                          }
+                        },
+                        {
+                          "type": "Identifier",
+                          "name": "d",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 66
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 67
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 62
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 68
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "k",
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 70
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 71
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 56
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 75
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 75
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 19
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 20
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 22
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": true,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 33
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 2,
+                        "column": 36
+                      },
+                      "end": {
+                        "line": 2,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 44
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 44
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 21
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 13
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 26
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 32
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 34
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 36
+                    }
+                  }
+                },
+                {
+                  "type": "TSCallSignatureDeclaration",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "d",
+                      "typeAnnotation": {
+                        "type": "TSBooleanKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 48
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 39
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "e",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 50
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 51
+                        }
+                      }
+                    }
+                  ],
+                  "returnType": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "g",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 58
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 64
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 55
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 56
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "l",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 69
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 75
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 66
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 67
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 80
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 86
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 86
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 88
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 88
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": true,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "StringLiteral",
+                    "value": "foo",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 11
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSBooleanKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 27
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": true,
+                  "optional": false,
+                  "key": {
+                    "type": "NumberLiteral",
+                    "value": 5,
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSUndefinedKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 44
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 33
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSAnyKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 4,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 4,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "optional": true,
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 4,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 4,
+                          "column": 47
+                        }
+                      }
+                    }
+                  ],
+                  "typeAnnotation": {
+                    "type": "TSNullKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 56
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 60
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 62
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 62
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 6
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 4,
+      "column": 62
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-type-literal.ts b/es2panda/test/parser/ts/test-type-literal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0146d36ac67dcd3aa53697ee07c45e9c5b8aa07a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { new(a: number, b: string): number; a: string; b?(a, [c, d], k?) }
+var b: { a: number, b: number; c?: string }
+var c: { a(a: number, b: string[]), (d: boolean, e): (g: number, l: string) => string }
+var d: { ["foo"]: boolean, [5](a: undefined, b?: any): null }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-literal1-expected.txt b/es2panda/test/parser/ts/test-type-literal1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c8f36c2959c0971b14c23ac39bc81adc95e4fdfd
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ']' expected [test-type-literal1.ts:1:13]
diff --git a/es2panda/test/parser/ts/test-type-literal1.ts b/es2panda/test/parser/ts/test-type-literal1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a42274690126ea639ef64ca2c9be3b01dfb1782
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { [a }
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-literal2-expected.txt b/es2panda/test/parser/ts/test-type-literal2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..79ece0a219887f2a9cdb199ab7b5417b97097fa3
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ',' expected [test-type-literal2.ts:1:14]
diff --git a/es2panda/test/parser/ts/test-type-literal2.ts b/es2panda/test/parser/ts/test-type-literal2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..449ac6fdf87c9f9deb192a820aa4745323cecbef
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { new a()}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-literal3-expected.txt b/es2panda/test/parser/ts/test-type-literal3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4c8797cc36d82e7e648395af88d60ebc41d10a6
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ',' expected [test-type-literal3.ts:1:12]
diff --git a/es2panda/test/parser/ts/test-type-literal3.ts b/es2panda/test/parser/ts/test-type-literal3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..19d6c9de3348b3b7120f27295cd671f44f60e25a
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-literal3.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: { a new ()}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-query-expected.txt b/es2panda/test/parser/ts/test-type-query-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31751ca771f14b55169485ec1b07dc2ff3f00c56
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-query-expected.txt
@@ -0,0 +1,599 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 14
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSTypeQuery",
+              "exprName": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 2,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSTypeLiteral",
+              "members": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "o",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "k",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSTypeQuery",
+                          "exprName": {
+                            "type": "TSQualifiedName",
+                            "left": {
+                              "type": "Identifier",
+                              "name": "c",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 3,
+                                  "column": 25
+                                },
+                                "end": {
+                                  "line": 3,
+                                  "column": 26
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "Identifier",
+                              "name": "o",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 3,
+                                  "column": 27
+                                },
+                                "end": {
+                                  "line": 3,
+                                  "column": 28
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 3,
+                                "column": 25
+                              },
+                              "end": {
+                                "line": 3,
+                                "column": 30
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 3,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 3,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 3,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 3,
+                            "column": 30
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 3,
+                  "column": 8
+                },
+                "end": {
+                  "line": 3,
+                  "column": 32
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 3,
+                "column": 5
+              },
+              "end": {
+                "line": 3,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 3,
+              "column": 5
+            },
+            "end": {
+              "line": 3,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 33
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 15
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 16
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 16
+                    }
+                  }
+                },
+                {
+                  "type": "TSTypeQuery",
+                  "exprName": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 27
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 27
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 8
+                },
+                "end": {
+                  "line": 4,
+                  "column": 27
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 4,
+              "column": 5
+            },
+            "end": {
+              "line": 4,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 4,
+          "column": 1
+        },
+        "end": {
+          "line": 4,
+          "column": 28
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSTypeQuery",
+                "exprName": {
+                  "type": "Identifier",
+                  "name": "d",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 41
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 42
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 34
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 42
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 8
+                },
+                "end": {
+                  "line": 5,
+                  "column": 42
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 5,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 5
+            },
+            "end": {
+              "line": 5,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 43
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 5,
+      "column": 43
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test-type-query.ts b/es2panda/test/parser/ts/test-type-query.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f4ec555d852703835adfd9c523d0517f0d51b28e
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-query.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: number
+var b: typeof a;
+var c: { o: { k: typeof c.o } };
+var d: typeof c | typeof a;
+var e: (a: number, b: string) => typeof d;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-query1-expected.txt b/es2panda/test/parser/ts/test-type-query1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ddc9ba37d5e1ccd464353d4f47aab9b196d048f2
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-query1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Identifier expected. [test-type-query1.ts:1:15]
diff --git a/es2panda/test/parser/ts/test-type-query1.ts b/es2panda/test/parser/ts/test-type-query1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c35ac32fb84fa55a0233c7daf1ea33f586ae8379
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-query1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: typeof 5;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test-type-query2-expected.txt b/es2panda/test/parser/ts/test-type-query2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bd1c600b541f09b625f5961889be243f67a5ded3
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-query2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Identifier expected. [test-type-query2.ts:1:14]
diff --git a/es2panda/test/parser/ts/test-type-query2.ts b/es2panda/test/parser/ts/test-type-query2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..777da8bd08165e7839c1513415a52214132a2544
--- /dev/null
+++ b/es2panda/test/parser/ts/test-type-query2.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: typeof
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator-expected.txt b/es2panda/test/parser/ts/test_decorator-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dd7d13e9fb97285f2a3bd3f35469e00bb8a0a581
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator-expected.txt
@@ -0,0 +1,1023 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ExportDefaultDeclaration",
+      "declaration": {
+        "type": "ClassDeclaration",
+        "definition": {
+          "id": {
+            "type": "Identifier",
+            "name": "Baz",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 22
+              },
+              "end": {
+                "line": 2,
+                "column": 25
+              }
+            }
+          },
+          "superClass": null,
+          "implements": [],
+          "constructor": {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 5
+                },
+                "end": {
+                  "line": 11,
+                  "column": 16
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSAnyKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 26
+                        }
+                      }
+                    },
+                    "decorators": [
+                      {
+                        "type": "Decorator",
+                        "expression": {
+                          "type": "Identifier",
+                          "name": "g",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 11,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 11,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 11,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 11,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 31
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 16
+                },
+                "end": {
+                  "line": 11,
+                  "column": 31
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 31
+              }
+            }
+          },
+          "body": [
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "Identifier",
+                "name": "a",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 6
+                  }
+                }
+              },
+              "kind": "method",
+              "static": false,
+              "optional": false,
+              "computed": false,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 12
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 12
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 6
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 12
+                  }
+                }
+              },
+              "overloads": [
+                {
+                  "type": "MethodDefinition",
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 5
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 6
+                      }
+                    }
+                  },
+                  "kind": "method",
+                  "static": false,
+                  "optional": false,
+                  "computed": false,
+                  "value": {
+                    "type": "FunctionExpression",
+                    "function": {
+                      "type": "ScriptFunction",
+                      "id": null,
+                      "generator": false,
+                      "async": false,
+                      "expression": false,
+                      "params": [],
+                      "loc": {
+                        "start": {
+                          "line": 3,
+                          "column": 6
+                        },
+                        "end": {
+                          "line": 3,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 3,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 3,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "overloads": [],
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 3,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 3,
+                      "column": 9
+                    }
+                  }
+                }
+              ],
+              "decorators": [
+                {
+                  "type": "Decorator",
+                  "expression": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 4,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 4,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 7
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 5,
+                  "column": 12
+                }
+              }
+            },
+            {
+              "type": "ClassProperty",
+              "key": {
+                "type": "Identifier",
+                "name": "c",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 6
+                  }
+                }
+              },
+              "static": false,
+              "readonly": false,
+              "declare": false,
+              "optional": false,
+              "computed": false,
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 14
+                  }
+                }
+              },
+              "decorators": [
+                {
+                  "type": "Decorator",
+                  "expression": {
+                    "type": "Identifier",
+                    "name": "d",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 7
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 10
+                  }
+                }
+              },
+              "kind": "set",
+              "static": false,
+              "optional": false,
+              "computed": false,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "f",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 9,
+                          "column": 11
+                        },
+                        "end": {
+                          "line": 9,
+                          "column": 12
+                        }
+                      }
+                    }
+                  ],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [],
+                    "loc": {
+                      "start": {
+                        "line": 9,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 9,
+                        "column": 17
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 9,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 9,
+                      "column": 17
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 9,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 9,
+                    "column": 17
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [
+                {
+                  "type": "Decorator",
+                  "expression": {
+                    "type": "CallExpression",
+                    "callee": {
+                      "type": "Identifier",
+                      "name": "e",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 6
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 7
+                        }
+                      }
+                    },
+                    "arguments": [],
+                    "optional": false,
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 9
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 9,
+                  "column": 17
+                }
+              }
+            },
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 10
+                  }
+                }
+              },
+              "kind": "get",
+              "static": false,
+              "optional": false,
+              "computed": false,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [
+                      {
+                        "type": "ReturnStatement",
+                        "argument": {
+                          "type": "NumberLiteral",
+                          "value": 1,
+                          "loc": {
+                            "start": {
+                              "line": 10,
+                              "column": 22
+                            },
+                            "end": {
+                              "line": 10,
+                              "column": 23
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 10,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 10,
+                            "column": 24
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 10,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 10,
+                        "column": 26
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 10,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 10,
+                      "column": 26
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 10,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 10,
+                    "column": 26
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 10,
+                  "column": 5
+                },
+                "end": {
+                  "line": 10,
+                  "column": 26
+                }
+              }
+            },
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 14
+                  }
+                }
+              },
+              "kind": "method",
+              "static": false,
+              "optional": false,
+              "computed": true,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 12,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 12,
+                    "column": 21
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [
+                {
+                  "type": "Decorator",
+                  "expression": {
+                    "type": "Identifier",
+                    "name": "dec",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 12,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 12,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 12,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 12,
+                      "column": 9
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 12,
+                  "column": 5
+                },
+                "end": {
+                  "line": 12,
+                  "column": 21
+                }
+              }
+            },
+            {
+              "type": "MethodDefinition",
+              "key": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 18
+                  }
+                }
+              },
+              "kind": "method",
+              "static": false,
+              "optional": false,
+              "computed": true,
+              "value": {
+                "type": "FunctionExpression",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": null,
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [],
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 25
+                  }
+                }
+              },
+              "overloads": [],
+              "decorators": [
+                {
+                  "type": "Decorator",
+                  "expression": {
+                    "type": "MemberExpression",
+                    "object": {
+                      "type": "Identifier",
+                      "name": "dec",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 6
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "property": {
+                      "type": "Identifier",
+                      "name": "dec",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 13,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 13,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "computed": false,
+                    "optional": false,
+                    "loc": {
+                      "start": {
+                        "line": 13,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 13,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 13
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 5
+                },
+                "end": {
+                  "line": 13,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "indexSignatures": [],
+          "loc": {
+            "start": {
+              "line": 2,
+              "column": 26
+            },
+            "end": {
+              "line": 14,
+              "column": 2
+            }
+          }
+        },
+        "decorators": [
+          {
+            "type": "Decorator",
+            "expression": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 2
+                },
+                "end": {
+                  "line": 1,
+                  "column": 5
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 5
+              }
+            }
+          },
+          {
+            "type": "Decorator",
+            "expression": {
+              "type": "CallExpression",
+              "callee": {
+                "type": "Identifier",
+                "name": "bar",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 10
+                  }
+                }
+              },
+              "arguments": [],
+              "optional": false,
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 7
+                },
+                "end": {
+                  "line": 1,
+                  "column": 12
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 6
+              },
+              "end": {
+                "line": 1,
+                "column": 12
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 2,
+            "column": 16
+          },
+          "end": {
+            "line": 14,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 2,
+          "column": 1
+        },
+        "end": {
+          "line": 14,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 14,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test_decorator.ts b/es2panda/test/parser/ts/test_decorator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ad4c0b74b71fdc9d15124891e2020246de826c7f
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator.ts
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+@foo @bar()
+export default class Baz {
+    a();
+    @c
+    a() { }
+    @d
+    c: number;
+    @e()
+    set b(f) { };
+    get b() { return 1; };
+    constructor(@g a: any) { };
+    @dec ["1"]() { }
+    @dec.dec ["h"]() { }
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator1-expected.txt b/es2panda/test/parser/ts/test_decorator1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5756801db11e8037c81ac020ff9e6a18673664fb
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected an identifier. [test_decorator1.ts:1:14]
diff --git a/es2panda/test/parser/ts/test_decorator1.ts b/es2panda/test/parser/ts/test_decorator1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ad35ff16997d8c68df717b3bebbc01bbbbe797af
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function foo(@dec a) { };
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator2-expected.txt b/es2panda/test/parser/ts/test_decorator2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6aa655d475d4ba3f7e7180342c6b8e8284f0f082
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Decorators are not valid here. [test_decorator2.ts:1:1]
diff --git a/es2panda/test/parser/ts/test_decorator2.ts b/es2panda/test/parser/ts/test_decorator2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a904974dd1b1b0bbef0eb34e6615f1a0bfac4fe8
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator2.ts
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+@bar;
+class Foo {
+
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator3-expected.txt b/es2panda/test/parser/ts/test_decorator3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cde08d7db4de551ecf0a7792625657d43339a527
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Decorators cannot be applied to multiple get/set accessors of the same name. [test_decorator3.ts:4:5]
diff --git a/es2panda/test/parser/ts/test_decorator3.ts b/es2panda/test/parser/ts/test_decorator3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5d55ddf958aaea7c6005048e7b3fe4d0bbde6d33
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator3.ts
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+@bar
+class Foo {
+    @dec set baz(a) { };
+    @dec get baz() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator4-expected.txt b/es2panda/test/parser/ts/test_decorator4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..563157f0c7b717b424e35b4bac1a7c3a9aeb6e4b
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A decorator can only decorate a method implementation, not an overload. [test_decorator4.ts:2:5]
diff --git a/es2panda/test/parser/ts/test_decorator4.ts b/es2panda/test/parser/ts/test_decorator4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8dec3658df174ed28e7c6a61f10b9155eadc6246
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    @dec a();
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator5-expected.txt b/es2panda/test/parser/ts/test_decorator5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a063375822a1c0a9d4950ebd034e031c691bcc37
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Decorators are not valid here. [test_decorator5.ts:2:5]
diff --git a/es2panda/test/parser/ts/test_decorator5.ts b/es2panda/test/parser/ts/test_decorator5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8a51550bf7ccb4551b4661ecde5046d9b07f5983
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    @dec constructor() { };
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator6-expected.txt b/es2panda/test/parser/ts/test_decorator6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b939da56ec0f29a44b84173d5bb88a53406d3634
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Decorators are not valid here. [test_decorator6.ts:2:5]
diff --git a/es2panda/test/parser/ts/test_decorator6.ts b/es2panda/test/parser/ts/test_decorator6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88ccd8408c9b65743e6eac6f617b746031178a7b
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator6.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class Foo {
+    @dec [a: number]: string;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator7-expected.txt b/es2panda/test/parser/ts/test_decorator7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5c4c061abf2e8460df6adcc7374e46b6ab2d29a3
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator7-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Decorators are not valid here. [test_decorator7.ts:1:1]
diff --git a/es2panda/test/parser/ts/test_decorator7.ts b/es2panda/test/parser/ts/test_decorator7.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9726df035cfb20c916ad6257311ef16858c7cee2
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator7.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+@bar
+export default function foo() {
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_decorator8-expected.txt b/es2panda/test/parser/ts/test_decorator8-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5b5ac27c07842ff632e43835bc23f57cfc289290
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator8-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Decorators are not valid here. [test_decorator8.ts:1:1]
diff --git a/es2panda/test/parser/ts/test_decorator8.ts b/es2panda/test/parser/ts/test_decorator8.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fb983d6d42cda3dfe52760faa92b43035495e8e1
--- /dev/null
+++ b/es2panda/test/parser/ts/test_decorator8.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+@bar
+export function foo() {
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_generic-expected.txt b/es2panda/test/parser/ts/test_generic-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..730e728ca7a24397c7690d0c85839275fbb44b4c
--- /dev/null
+++ b/es2panda/test/parser/ts/test_generic-expected.txt
@@ -0,0 +1,7045 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 10
+            },
+            "end": {
+              "line": 1,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "arg",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Type",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 59
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 63
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 59
+                },
+                "end": {
+                  "line": 1,
+                  "column": 63
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 54
+              },
+              "end": {
+                "line": 1,
+                "column": 57
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSTypeReference",
+          "typeName": {
+            "type": "Identifier",
+            "name": "Type",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 66
+              },
+              "end": {
+                "line": 1,
+                "column": 70
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 66
+            },
+            "end": {
+              "line": 1,
+              "column": 70
+            }
+          }
+        },
+        "typeParameters": {
+          "type": "TSTypeParameterDeclaration",
+          "params": [
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "Type",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 16
+                },
+                "end": {
+                  "line": 1,
+                  "column": 21
+                }
+              }
+            },
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 22
+                },
+                "end": {
+                  "line": 1,
+                  "column": 24
+                }
+              }
+            },
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 25
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 26
+                  }
+                }
+              },
+              "constraint": {
+                "type": "TSTypeOperator",
+                "operator": "readonly",
+                "typeAnnotation": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 44
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 44
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 52
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 35
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 52
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 25
+                },
+                "end": {
+                  "line": 1,
+                  "column": 53
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 15
+            },
+            "end": {
+              "line": 1,
+              "column": 53
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "Identifier",
+                "name": "arg",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 15
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 16
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 71
+            },
+            "end": {
+              "line": 3,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 10
+            },
+            "end": {
+              "line": 5,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [],
+        "typeParameters": {
+          "type": "TSTypeParameterDeclaration",
+          "params": [
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 17
+                  }
+                }
+              },
+              "constraint": {
+                "type": "TSTypeLiteral",
+                "members": [
+                  {
+                    "type": "TSPropertySignature",
+                    "computed": false,
+                    "optional": false,
+                    "readonly": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 37
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 38
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSPropertySignature",
+                    "computed": false,
+                    "optional": false,
+                    "readonly": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "typeAnnotation": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 48
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 50
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 50
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 16
+                },
+                "end": {
+                  "line": 5,
+                  "column": 51
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 15
+            },
+            "end": {
+              "line": 5,
+              "column": 51
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 54
+            },
+            "end": {
+              "line": 5,
+              "column": 57
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 1
+          },
+          "end": {
+            "line": 5,
+            "column": 57
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 5,
+          "column": 57
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "func3",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 10
+            },
+            "end": {
+              "line": 7,
+              "column": 15
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 90
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 91
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 90
+                },
+                "end": {
+                  "line": 7,
+                  "column": 91
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 87
+              },
+              "end": {
+                "line": 7,
+                "column": 88
+              }
+            }
+          },
+          {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 96
+                },
+                "end": {
+                  "line": 7,
+                  "column": 102
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 7,
+                "column": 93
+              },
+              "end": {
+                "line": 7,
+                "column": 94
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSUnionType",
+          "types": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 105
+                },
+                "end": {
+                  "line": 7,
+                  "column": 111
+                }
+              }
+            },
+            {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 114
+                },
+                "end": {
+                  "line": 7,
+                  "column": 121
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 105
+            },
+            "end": {
+              "line": 7,
+              "column": 121
+            }
+          }
+        },
+        "typeParameters": {
+          "type": "TSTypeParameterDeclaration",
+          "params": [
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 17
+                  }
+                }
+              },
+              "constraint": {
+                "type": "TSTypeOperator",
+                "operator": "keyof",
+                "typeAnnotation": {
+                  "type": "TSTypeLiteral",
+                  "members": [
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 34
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 35
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTypeLiteral",
+                        "members": [
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "b",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 7,
+                                  "column": 39
+                                },
+                                "end": {
+                                  "line": 7,
+                                  "column": 40
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 7,
+                                  "column": 42
+                                },
+                                "end": {
+                                  "line": 7,
+                                  "column": 48
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 7,
+                                "column": 39
+                              },
+                              "end": {
+                                "line": 7,
+                                "column": 49
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSPropertySignature",
+                            "computed": false,
+                            "optional": false,
+                            "readonly": false,
+                            "key": {
+                              "type": "Identifier",
+                              "name": "c",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 7,
+                                  "column": 50
+                                },
+                                "end": {
+                                  "line": 7,
+                                  "column": 51
+                                }
+                              }
+                            },
+                            "typeAnnotation": {
+                              "type": "TSBooleanKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 7,
+                                  "column": 53
+                                },
+                                "end": {
+                                  "line": 7,
+                                  "column": 60
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 7,
+                                "column": 50
+                              },
+                              "end": {
+                                "line": 7,
+                                "column": 62
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 37
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 34
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 63
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSPropertySignature",
+                      "computed": false,
+                      "optional": false,
+                      "readonly": false,
+                      "key": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 64
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 65
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSTupleType",
+                        "elementTypes": [
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 7,
+                                "column": 68
+                              },
+                              "end": {
+                                "line": 7,
+                                "column": 75
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 7,
+                                "column": 76
+                              },
+                              "end": {
+                                "line": 7,
+                                "column": 83
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 7,
+                            "column": 67
+                          },
+                          "end": {
+                            "line": 7,
+                            "column": 83
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 7,
+                          "column": 64
+                        },
+                        "end": {
+                          "line": 7,
+                          "column": 85
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 7,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 85
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 7,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 7,
+                    "column": 85
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 7,
+                  "column": 16
+                },
+                "end": {
+                  "line": 7,
+                  "column": 86
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 15
+            },
+            "end": {
+              "line": 7,
+              "column": 86
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [
+            {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "BooleanLiteral",
+                "value": true,
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 16
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 5
+                },
+                "end": {
+                  "line": 8,
+                  "column": 17
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 7,
+              "column": 122
+            },
+            "end": {
+              "line": 9,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 7,
+            "column": 1
+          },
+          "end": {
+            "line": 9,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 7,
+          "column": 1
+        },
+        "end": {
+          "line": 9,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "PromiseConstructorLike",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 14
+          },
+          "end": {
+            "line": 11,
+            "column": 36
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSConstructorType",
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "executor",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "resolve",
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "value",
+                        "typeAnnotation": {
+                          "type": "TSUnionType",
+                          "types": [
+                            {
+                              "type": "TSTypeReference",
+                              "typeName": {
+                                "type": "Identifier",
+                                "name": "T",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 11,
+                                    "column": 75
+                                  },
+                                  "end": {
+                                    "line": 11,
+                                    "column": 76
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 11,
+                                  "column": 75
+                                },
+                                "end": {
+                                  "line": 11,
+                                  "column": 76
+                                }
+                              }
+                            },
+                            {
+                              "type": "TSTypeReference",
+                              "typeName": {
+                                "type": "Identifier",
+                                "name": "PromiseLike",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 11,
+                                    "column": 79
+                                  },
+                                  "end": {
+                                    "line": 11,
+                                    "column": 90
+                                  }
+                                }
+                              },
+                              "typeParameters": {
+                                "type": "TSTypeParameterInstantiation",
+                                "params": [
+                                  {
+                                    "type": "TSTypeReference",
+                                    "typeName": {
+                                      "type": "Identifier",
+                                      "name": "T",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 11,
+                                          "column": 91
+                                        },
+                                        "end": {
+                                          "line": 11,
+                                          "column": 92
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 11,
+                                        "column": 91
+                                      },
+                                      "end": {
+                                        "line": 11,
+                                        "column": 92
+                                      }
+                                    }
+                                  }
+                                ],
+                                "loc": {
+                                  "start": {
+                                    "line": 11,
+                                    "column": 79
+                                  },
+                                  "end": {
+                                    "line": 11,
+                                    "column": 93
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 11,
+                                  "column": 79
+                                },
+                                "end": {
+                                  "line": 11,
+                                  "column": 90
+                                }
+                              }
+                            }
+                          ],
+                          "loc": {
+                            "start": {
+                              "line": 11,
+                              "column": 75
+                            },
+                            "end": {
+                              "line": 11,
+                              "column": 90
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 11,
+                            "column": 68
+                          },
+                          "end": {
+                            "line": 11,
+                            "column": 73
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSVoidKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 98
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 102
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 102
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 58
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 65
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "reject",
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "reason",
+                        "typeAnnotation": {
+                          "type": "TSAnyKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 11,
+                              "column": 122
+                            },
+                            "end": {
+                              "line": 11,
+                              "column": 125
+                            }
+                          }
+                        },
+                        "optional": true,
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 11,
+                            "column": 113
+                          },
+                          "end": {
+                            "line": 11,
+                            "column": 119
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSVoidKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 11,
+                          "column": 130
+                        },
+                        "end": {
+                          "line": 11,
+                          "column": 134
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 11,
+                        "column": 112
+                      },
+                      "end": {
+                        "line": 11,
+                        "column": 134
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 104
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 110
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSVoidKeyword",
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 139
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 143
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 57
+                },
+                "end": {
+                  "line": 11,
+                  "column": 143
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 47
+              },
+              "end": {
+                "line": 11,
+                "column": 55
+              }
+            }
+          }
+        ],
+        "typeParameters": {
+          "type": "TSTypeParameterDeclaration",
+          "params": [
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 44
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 45
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 11,
+                  "column": 44
+                },
+                "end": {
+                  "line": 11,
+                  "column": 46
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 43
+            },
+            "end": {
+              "line": 11,
+              "column": 46
+            }
+          }
+        },
+        "returnType": {
+          "type": "TSTypeReference",
+          "typeName": {
+            "type": "Identifier",
+            "name": "PromiseLike",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 148
+              },
+              "end": {
+                "line": 11,
+                "column": 159
+              }
+            }
+          },
+          "typeParameters": {
+            "type": "TSTypeParameterInstantiation",
+            "params": [
+              {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "T",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 160
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 161
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 160
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 161
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 148
+              },
+              "end": {
+                "line": 11,
+                "column": 162
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 11,
+              "column": 148
+            },
+            "end": {
+              "line": 11,
+              "column": 159
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 11,
+            "column": 39
+          },
+          "end": {
+            "line": 11,
+            "column": 159
+          }
+        }
+      },
+      "declare": true,
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 9
+        },
+        "end": {
+          "line": 11,
+          "column": 163
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 11,
+          "column": 162
+        },
+        "end": {
+          "line": 11,
+          "column": 163
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 5
+                },
+                "end": {
+                  "line": 14,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 14,
+                  "column": 8
+                },
+                "end": {
+                  "line": 14,
+                  "column": 14
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 14,
+                "column": 5
+              },
+              "end": {
+                "line": 14,
+                "column": 15
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSStringKeyword",
+                "loc": {
+                  "start": {
+                    "line": 15,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 15,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 6
+                },
+                "end": {
+                  "line": 15,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 25
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 15,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 15,
+                      "column": 34
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 15,
+                  "column": 18
+                },
+                "end": {
+                  "line": 15,
+                  "column": 34
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 15,
+                "column": 5
+              },
+              "end": {
+                "line": 15,
+                "column": 35
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 53
+          },
+          "end": {
+            "line": 16,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "R",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 11
+          },
+          "end": {
+            "line": 13,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "K",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 13
+                },
+                "end": {
+                  "line": 13,
+                  "column": 14
+                }
+              }
+            },
+            "constraint": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 31
+                    }
+                  }
+                },
+                {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 13,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 13,
+                      "column": 39
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 23
+                },
+                "end": {
+                  "line": 13,
+                  "column": 39
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 13
+              },
+              "end": {
+                "line": 13,
+                "column": 40
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 41
+                },
+                "end": {
+                  "line": 13,
+                  "column": 42
+                }
+              }
+            },
+            "default": {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 45
+                },
+                "end": {
+                  "line": 13,
+                  "column": 51
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 41
+              },
+              "end": {
+                "line": 13,
+                "column": 52
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 13,
+            "column": 12
+          },
+          "end": {
+            "line": 13,
+            "column": 52
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 13,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSCallSignatureDeclaration",
+            "params": [],
+            "typeParameters": {
+              "type": "TSTypeParameterDeclaration",
+              "params": [
+                {
+                  "type": "TSTypeParameter",
+                  "name": {
+                    "type": "Identifier",
+                    "name": "A",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 19,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 19,
+                        "column": 7
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 8
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 5
+                },
+                "end": {
+                  "line": 19,
+                  "column": 8
+                }
+              }
+            },
+            "returnType": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 12
+                },
+                "end": {
+                  "line": 19,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 5
+              },
+              "end": {
+                "line": 19,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "TSMethodSignature",
+            "computed": false,
+            "optional": false,
+            "key": {
+              "type": "Identifier",
+              "name": "readonly",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 5
+                },
+                "end": {
+                  "line": 20,
+                  "column": 13
+                }
+              }
+            },
+            "params": [],
+            "typeParameters": {
+              "type": "TSTypeParameterDeclaration",
+              "params": [
+                {
+                  "type": "TSTypeParameter",
+                  "name": {
+                    "type": "Identifier",
+                    "name": "A",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "constraint": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 31
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 13
+                },
+                "end": {
+                  "line": 20,
+                  "column": 31
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSBooleanKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 36
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 44
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 45
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 51
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 45
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 54
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 35
+                },
+                "end": {
+                  "line": 20,
+                  "column": 54
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 5
+              },
+              "end": {
+                "line": 20,
+                "column": 55
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 117
+          },
+          "end": {
+            "line": 21,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "U",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 11
+          },
+          "end": {
+            "line": 18,
+            "column": 12
+          }
+        }
+      },
+      "extends": [
+        {
+          "type": "TSInterfaceHeritage",
+          "expression": {
+            "type": "Identifier",
+            "name": "R",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 97
+              },
+              "end": {
+                "line": 18,
+                "column": 98
+              }
+            }
+          },
+          "typeParameters": {
+            "type": "TSTypeParameterInstantiation",
+            "params": [
+              {
+                "type": "TSTupleType",
+                "elementTypes": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 100
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 107
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSStringKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 108
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 115
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 99
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 115
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 97
+              },
+              "end": {
+                "line": 18,
+                "column": 116
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 18,
+              "column": 117
+            },
+            "end": {
+              "line": 18,
+              "column": 116
+            }
+          }
+        }
+      ],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 13
+                },
+                "end": {
+                  "line": 18,
+                  "column": 14
+                }
+              }
+            },
+            "constraint": {
+              "type": "TSTypeOperator",
+              "operator": "readonly",
+              "typeAnnotation": {
+                "type": "TSTupleType",
+                "elementTypes": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 33
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 40
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 41
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 48
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 18,
+                              "column": 51
+                            },
+                            "end": {
+                              "line": 18,
+                              "column": 52
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 18,
+                              "column": 54
+                            },
+                            "end": {
+                              "line": 18,
+                              "column": 60
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 18,
+                            "column": 51
+                          },
+                          "end": {
+                            "line": 18,
+                            "column": 61
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 18,
+                              "column": 62
+                            },
+                            "end": {
+                              "line": 18,
+                              "column": 63
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 18,
+                              "column": 65
+                            },
+                            "end": {
+                              "line": 18,
+                              "column": 71
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 18,
+                            "column": 62
+                          },
+                          "end": {
+                            "line": 18,
+                            "column": 73
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 18,
+                        "column": 49
+                      },
+                      "end": {
+                        "line": 18,
+                        "column": 74
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 18,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 74
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 23
+                },
+                "end": {
+                  "line": 18,
+                  "column": 74
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 13
+              },
+              "end": {
+                "line": 18,
+                "column": 75
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "Z",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 76
+                },
+                "end": {
+                  "line": 18,
+                  "column": 77
+                }
+              }
+            },
+            "default": {
+              "type": "TSBooleanKeyword",
+              "loc": {
+                "start": {
+                  "line": 18,
+                  "column": 80
+                },
+                "end": {
+                  "line": 18,
+                  "column": 87
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 18,
+                "column": 76
+              },
+              "end": {
+                "line": 18,
+                "column": 88
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 12
+          },
+          "end": {
+            "line": 18,
+            "column": 88
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func1",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 1
+            },
+            "end": {
+              "line": 23,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "typeParameters": {
+          "type": "TSTypeParameterInstantiation",
+          "params": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 7
+                },
+                "end": {
+                  "line": 23,
+                  "column": 13
+                }
+              }
+            },
+            {
+              "type": "TSStringKeyword",
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 15
+                },
+                "end": {
+                  "line": 23,
+                  "column": 21
+                }
+              }
+            },
+            {
+              "type": "TSTupleType",
+              "elementTypes": [
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "NumberLiteral",
+                    "value": 1,
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 26
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "NumberLiteral",
+                    "value": 2,
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 28
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 27
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 29
+                    }
+                  }
+                },
+                {
+                  "type": "TSLiteralType",
+                  "literal": {
+                    "type": "NumberLiteral",
+                    "value": 3,
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 31
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 32
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 23
+                },
+                "end": {
+                  "line": 23,
+                  "column": 32
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 6
+            },
+            "end": {
+              "line": 23,
+              "column": 33
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 1
+          },
+          "end": {
+            "line": 23,
+            "column": 35
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 35
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "func2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 1
+            },
+            "end": {
+              "line": 24,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "typeParameters": {
+          "type": "TSTypeParameterInstantiation",
+          "params": [
+            {
+              "type": "TSFunctionType",
+              "params": [],
+              "typeParameters": {
+                "type": "TSTypeParameterDeclaration",
+                "params": [
+                  {
+                    "type": "TSTypeParameter",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 10
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 10
+                  }
+                }
+              },
+              "returnType": {
+                "type": "TSTypeLiteral",
+                "members": [],
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 7
+                },
+                "end": {
+                  "line": 24,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 24,
+              "column": 6
+            },
+            "end": {
+              "line": 24,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 24,
+            "column": 1
+          },
+          "end": {
+            "line": 24,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 24,
+          "column": 1
+        },
+        "end": {
+          "line": 24,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "o",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 5
+              },
+              "end": {
+                "line": 26,
+                "column": 6
+              }
+            }
+          },
+          "init": {
+            "type": "ObjectExpression",
+            "properties": [
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "typeParameters": {
+                      "type": "TSTypeParameterDeclaration",
+                      "params": [
+                        {
+                          "type": "TSTypeParameter",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "B",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 18
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 20
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSTypeParameter",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "C",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 21
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 22
+                              }
+                            }
+                          },
+                          "constraint": {
+                            "type": "TSTypeQuery",
+                            "exprName": {
+                              "type": "Identifier",
+                              "name": "func1",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 27,
+                                  "column": 38
+                                },
+                                "end": {
+                                  "line": 27,
+                                  "column": 43
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 31
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 43
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 44
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 44
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 47
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 50
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 27,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 27,
+                        "column": 50
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 50
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 27,
+                    "column": 50
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": false,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "typeParameters": {
+                      "type": "TSTypeParameterDeclaration",
+                      "params": [
+                        {
+                          "type": "TSTypeParameter",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "D",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 18
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "default": {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 28
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 28,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 28,
+                              "column": 29
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSTypeParameter",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "T",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 30
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 31
+                              }
+                            }
+                          },
+                          "default": {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 34
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 40
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 28,
+                              "column": 30
+                            },
+                            "end": {
+                              "line": 28,
+                              "column": 41
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 28,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 28,
+                          "column": 41
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 28,
+                          "column": 44
+                        },
+                        "end": {
+                          "line": 28,
+                          "column": 47
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 28,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 28,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 47
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 47
+                  }
+                }
+              },
+              {
+                "type": "Property",
+                "method": true,
+                "shorthand": false,
+                "computed": false,
+                "key": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 6
+                    }
+                  }
+                },
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": null,
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [],
+                    "typeParameters": {
+                      "type": "TSTypeParameterDeclaration",
+                      "params": [
+                        {
+                          "type": "TSTypeParameter",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "E",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 7
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 8
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 29,
+                              "column": 7
+                            },
+                            "end": {
+                              "line": 29,
+                              "column": 9
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSTypeParameter",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "F",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 10
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 11
+                              }
+                            }
+                          },
+                          "constraint": {
+                            "type": "TSTypeOperator",
+                            "operator": "readonly",
+                            "typeAnnotation": {
+                              "type": "TSTupleType",
+                              "elementTypes": [],
+                              "loc": {
+                                "start": {
+                                  "line": 29,
+                                  "column": 29
+                                },
+                                "end": {
+                                  "line": 29,
+                                  "column": 31
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 20
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 31
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 29,
+                              "column": 10
+                            },
+                            "end": {
+                              "line": 29,
+                              "column": 32
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 6
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 35
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 38
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 6
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 38
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 6
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 38
+                    }
+                  }
+                },
+                "kind": "init",
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 38
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 26,
+                "column": 9
+              },
+              "end": {
+                "line": 30,
+                "column": 2
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 26,
+              "column": 5
+            },
+            "end": {
+              "line": 30,
+              "column": 2
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 26,
+          "column": 1
+        },
+        "end": {
+          "line": 30,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 7
+            },
+            "end": {
+              "line": 32,
+              "column": 8
+            }
+          }
+        },
+        "typeParameters": {
+          "type": "TSTypeParameterDeclaration",
+          "params": [
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 10
+                  }
+                }
+              },
+              "constraint": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "Identifier",
+                  "name": "B",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 20
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 9
+                },
+                "end": {
+                  "line": 32,
+                  "column": 21
+                }
+              }
+            },
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "Z",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 23
+                  }
+                }
+              },
+              "default": {
+                "type": "TSTypeLiteral",
+                "members": [
+                  {
+                    "type": "TSPropertySignature",
+                    "computed": false,
+                    "optional": false,
+                    "readonly": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 31
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 37
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 28
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 38
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSPropertySignature",
+                    "computed": false,
+                    "optional": false,
+                    "readonly": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 40
+                        }
+                      }
+                    },
+                    "typeAnnotation": {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 42
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 48
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 50
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 50
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 32,
+                  "column": 22
+                },
+                "end": {
+                  "line": 32,
+                  "column": 51
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 8
+            },
+            "end": {
+              "line": 32,
+              "column": 51
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 1
+            },
+            "end": {
+              "line": 35,
+              "column": 2
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 12
+                },
+                "end": {
+                  "line": 33,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "typeParameters": {
+                  "type": "TSTypeParameterDeclaration",
+                  "params": [
+                    {
+                      "type": "TSTypeParameter",
+                      "name": {
+                        "type": "Identifier",
+                        "name": "T",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 16
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSTypeParameter",
+                      "name": {
+                        "type": "Identifier",
+                        "name": "R",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 17
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 19
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 19
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 33,
+                    "column": 25
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 13
+                },
+                "end": {
+                  "line": 33,
+                  "column": 25
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 5
+              },
+              "end": {
+                "line": 33,
+                "column": 25
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 13
+                },
+                "end": {
+                  "line": 34,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "private",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": null,
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "typeParameters": {
+                  "type": "TSTypeParameterDeclaration",
+                  "params": [
+                    {
+                      "type": "TSTypeParameter",
+                      "name": {
+                        "type": "Identifier",
+                        "name": "E",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 16
+                          }
+                        }
+                      },
+                      "constraint": {
+                        "type": "TSFunctionType",
+                        "params": [
+                          {
+                            "type": "Identifier",
+                            "name": "a",
+                            "typeAnnotation": {
+                              "type": "TSNumberKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 29
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 35
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 26
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 27
+                              }
+                            }
+                          },
+                          {
+                            "type": "Identifier",
+                            "name": "b",
+                            "typeAnnotation": {
+                              "type": "TSStringKeyword",
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 40
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 46
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 37
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 38
+                              }
+                            }
+                          }
+                        ],
+                        "returnType": {
+                          "type": "TSArrayType",
+                          "elementType": {
+                            "type": "TSAnyKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 51
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 54
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 51
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 56
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 56
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 15
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 57
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 14
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 57
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 60
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 63
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 63
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 14
+                },
+                "end": {
+                  "line": 34,
+                  "column": 63
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 5
+              },
+              "end": {
+                "line": 34,
+                "column": 63
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 52
+          },
+          "end": {
+            "line": 35,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 35,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "W",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 7
+            },
+            "end": {
+              "line": 37,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "Identifier",
+          "name": "T",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 17
+            },
+            "end": {
+              "line": 37,
+              "column": 18
+            }
+          }
+        },
+        "superTypeParameters": {
+          "type": "TSTypeParameterInstantiation",
+          "params": [
+            {
+              "type": "TSFunctionType",
+              "params": [],
+              "typeParameters": {
+                "type": "TSTypeParameterDeclaration",
+                "params": [
+                  {
+                    "type": "TSTypeParameter",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "B",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 37,
+                          "column": 20
+                        },
+                        "end": {
+                          "line": 37,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 37,
+                        "column": 20
+                      },
+                      "end": {
+                        "line": 37,
+                        "column": 22
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 19
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 22
+                  }
+                }
+              },
+              "returnType": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 35
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 19
+                },
+                "end": {
+                  "line": 37,
+                  "column": 35
+                }
+              }
+            },
+            {
+              "type": "TSArrayType",
+              "elementType": {
+                "type": "TSTupleType",
+                "elementTypes": [
+                  {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 37,
+                            "column": 38
+                          },
+                          "end": {
+                            "line": 37,
+                            "column": 44
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 37,
+                            "column": 47
+                          },
+                          "end": {
+                            "line": 37,
+                            "column": 53
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 37,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 37,
+                        "column": 54
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 37,
+                    "column": 54
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 37
+                },
+                "end": {
+                  "line": 37,
+                  "column": 56
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 18
+            },
+            "end": {
+              "line": 37,
+              "column": 57
+            }
+          }
+        },
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "RestElement",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "args",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 1
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "ExpressionStatement",
+                    "expression": {
+                      "type": "CallExpression",
+                      "callee": {
+                        "type": "Super",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 1
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 1
+                          }
+                        }
+                      },
+                      "arguments": [
+                        {
+                          "type": "SpreadElement",
+                          "argument": {
+                            "type": "Identifier",
+                            "name": "args",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 1
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 1
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 1
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 1
+                            }
+                          }
+                        }
+                      ],
+                      "optional": false,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 1
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 1
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 37,
+              "column": 1
+            },
+            "end": {
+              "line": 39,
+              "column": 2
+            }
+          }
+        },
+        "body": [],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 58
+          },
+          "end": {
+            "line": 39,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "X",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 7
+            },
+            "end": {
+              "line": 41,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "Identifier",
+          "name": "Q",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 17
+            },
+            "end": {
+              "line": 41,
+              "column": 18
+            }
+          }
+        },
+        "superTypeParameters": {
+          "type": "TSTypeParameterInstantiation",
+          "params": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 19
+                },
+                "end": {
+                  "line": 41,
+                  "column": 25
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 18
+            },
+            "end": {
+              "line": 41,
+              "column": 26
+            }
+          }
+        },
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "Identifier",
+              "name": "S",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 38
+                },
+                "end": {
+                  "line": 41,
+                  "column": 39
+                }
+              }
+            },
+            "typeParameters": {
+              "type": "TSTypeParameterInstantiation",
+              "params": [
+                {
+                  "type": "TSFunctionType",
+                  "params": [
+                    {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 46
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 41,
+                          "column": 44
+                        },
+                        "end": {
+                          "line": 41,
+                          "column": 45
+                        }
+                      }
+                    },
+                    {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 56
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 62
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 41,
+                          "column": 54
+                        },
+                        "end": {
+                          "line": 41,
+                          "column": 55
+                        }
+                      }
+                    }
+                  ],
+                  "typeParameters": {
+                    "type": "TSTypeParameterDeclaration",
+                    "params": [
+                      {
+                        "type": "TSTypeParameter",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "R",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 41,
+                              "column": 41
+                            },
+                            "end": {
+                              "line": 41,
+                              "column": 42
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 43
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 40
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 43
+                      }
+                    }
+                  },
+                  "returnType": {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 41,
+                            "column": 68
+                          },
+                          "end": {
+                            "line": 41,
+                            "column": 75
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 41,
+                        "column": 67
+                      },
+                      "end": {
+                        "line": 41,
+                        "column": 75
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 41,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 41,
+                      "column": 75
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 39
+                },
+                "end": {
+                  "line": 41,
+                  "column": 76
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 38
+              },
+              "end": {
+                "line": 41,
+                "column": 77
+              }
+            }
+          },
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 41,
+                  "column": 78
+                },
+                "end": {
+                  "line": 41,
+                  "column": 79
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 41,
+                "column": 78
+              },
+              "end": {
+                "line": 41,
+                "column": 81
+              }
+            }
+          }
+        ],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [
+                {
+                  "type": "RestElement",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "args",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 1
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                }
+              ],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [
+                  {
+                    "type": "ExpressionStatement",
+                    "expression": {
+                      "type": "CallExpression",
+                      "callee": {
+                        "type": "Super",
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 1
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 1
+                          }
+                        }
+                      },
+                      "arguments": [
+                        {
+                          "type": "SpreadElement",
+                          "argument": {
+                            "type": "Identifier",
+                            "name": "args",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 1
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 1
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 1
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 1
+                            }
+                          }
+                        }
+                      ],
+                      "optional": false,
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 1
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 1
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 1
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 41,
+              "column": 1
+            },
+            "end": {
+              "line": 43,
+              "column": 2
+            }
+          }
+        },
+        "body": [],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 80
+          },
+          "end": {
+            "line": 43,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 43,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSConstructorType",
+              "params": [],
+              "typeParameters": {
+                "type": "TSTypeParameterDeclaration",
+                "params": [
+                  {
+                    "type": "TSTypeParameter",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 45,
+                          "column": 13
+                        },
+                        "end": {
+                          "line": 45,
+                          "column": 14
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 45,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 45,
+                        "column": 15
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 15
+                  }
+                }
+              },
+              "returnType": {
+                "type": "TSFunctionType",
+                "params": [],
+                "typeParameters": {
+                  "type": "TSTypeParameterDeclaration",
+                  "params": [
+                    {
+                      "type": "TSTypeParameter",
+                      "name": {
+                        "type": "Identifier",
+                        "name": "B",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 45,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 45,
+                            "column": 23
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 45,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 45,
+                          "column": 24
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 24
+                    }
+                  }
+                },
+                "returnType": {
+                  "type": "TSStringKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 45,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 36
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 45,
+                    "column": 21
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 45,
+                  "column": 8
+                },
+                "end": {
+                  "line": 45,
+                  "column": 36
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 45,
+                "column": 5
+              },
+              "end": {
+                "line": 45,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 45,
+              "column": 5
+            },
+            "end": {
+              "line": 45,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 45,
+          "column": 1
+        },
+        "end": {
+          "line": 45,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "b",
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSUnionType",
+                    "types": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 32
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 38
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 47
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 32
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 47
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 46,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 46,
+                      "column": 30
+                    }
+                  }
+                }
+              ],
+              "typeParameters": {
+                "type": "TSTypeParameterDeclaration",
+                "params": [
+                  {
+                    "type": "TSTypeParameter",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 10
+                        }
+                      }
+                    },
+                    "constraint": {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "T",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 21
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSTypeParameter",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "U",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 23
+                        }
+                      }
+                    },
+                    "default": {
+                      "type": "TSLiteralType",
+                      "literal": {
+                        "type": "NumberLiteral",
+                        "value": 5,
+                        "loc": {
+                          "start": {
+                            "line": 46,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 46,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 26
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 28
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 28
+                  }
+                }
+              },
+              "returnType": {
+                "type": "TSTypeLiteral",
+                "members": [
+                  {
+                    "type": "TSPropertySignature",
+                    "computed": false,
+                    "optional": false,
+                    "readonly": false,
+                    "key": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 54
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 55
+                        }
+                      }
+                    },
+                    "typeAnnotation": {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 46,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 46,
+                          "column": 63
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 46,
+                        "column": 54
+                      },
+                      "end": {
+                        "line": 46,
+                        "column": 65
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 46,
+                    "column": 52
+                  },
+                  "end": {
+                    "line": 46,
+                    "column": 65
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 46,
+                  "column": 8
+                },
+                "end": {
+                  "line": 46,
+                  "column": 65
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 46,
+                "column": 5
+              },
+              "end": {
+                "line": 46,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 46,
+              "column": 5
+            },
+            "end": {
+              "line": 46,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 46,
+          "column": 1
+        },
+        "end": {
+          "line": 46,
+          "column": 66
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "typeAnnotation": {
+              "type": "TSIndexedAccessType",
+              "objectType": {
+                "type": "TSTypeReference",
+                "typeName": {
+                  "type": "TSQualifiedName",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "B",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 48,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 48,
+                        "column": 9
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "Identifier",
+                    "name": "T",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 48,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 48,
+                        "column": 11
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 48,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 48,
+                      "column": 12
+                    }
+                  }
+                },
+                "typeParameters": {
+                  "type": "TSTypeParameterInstantiation",
+                  "params": [
+                    {
+                      "type": "TSTypeReference",
+                      "typeName": {
+                        "type": "Identifier",
+                        "name": "A",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 48,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 48,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "typeParameters": {
+                        "type": "TSTypeParameterInstantiation",
+                        "params": [
+                          {
+                            "type": "TSTypeReference",
+                            "typeName": {
+                              "type": "Identifier",
+                              "name": "C",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 48,
+                                  "column": 14
+                                },
+                                "end": {
+                                  "line": 48,
+                                  "column": 15
+                                }
+                              }
+                            },
+                            "typeParameters": {
+                              "type": "TSTypeParameterInstantiation",
+                              "params": [
+                                {
+                                  "type": "TSNumberKeyword",
+                                  "loc": {
+                                    "start": {
+                                      "line": 48,
+                                      "column": 16
+                                    },
+                                    "end": {
+                                      "line": 48,
+                                      "column": 22
+                                    }
+                                  }
+                                }
+                              ],
+                              "loc": {
+                                "start": {
+                                  "line": 48,
+                                  "column": 14
+                                },
+                                "end": {
+                                  "line": 48,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 48,
+                                "column": 14
+                              },
+                              "end": {
+                                "line": 48,
+                                "column": 15
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 48,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 48,
+                            "column": 25
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 48,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 48,
+                          "column": 13
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 48,
+                      "column": 11
+                    },
+                    "end": {
+                      "line": 48,
+                      "column": 25
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 48,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 48,
+                    "column": 26
+                  }
+                }
+              },
+              "indexType": {
+                "type": "TSLiteralType",
+                "literal": {
+                  "type": "NumberLiteral",
+                  "value": 0,
+                  "loc": {
+                    "start": {
+                      "line": 48,
+                      "column": 26
+                    },
+                    "end": {
+                      "line": 48,
+                      "column": 27
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 48,
+                    "column": 26
+                  },
+                  "end": {
+                    "line": 48,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 8
+                },
+                "end": {
+                  "line": 48,
+                  "column": 29
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 48,
+                "column": 5
+              },
+              "end": {
+                "line": 48,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 48,
+              "column": 5
+            },
+            "end": {
+              "line": 48,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 48,
+          "column": 1
+        },
+        "end": {
+          "line": 48,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "d",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "A",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 49,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 49,
+                    "column": 9
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 16
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSTypeLiteral",
+                    "members": [
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 49,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 49,
+                              "column": 21
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 49,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 49,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 30
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSPropertySignature",
+                        "computed": false,
+                        "optional": false,
+                        "readonly": false,
+                        "key": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 49,
+                              "column": 31
+                            },
+                            "end": {
+                              "line": 49,
+                              "column": 32
+                            }
+                          }
+                        },
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 49,
+                              "column": 34
+                            },
+                            "end": {
+                              "line": 49,
+                              "column": 40
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 31
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 42
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 42
+                      }
+                    }
+                  },
+                  {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 45
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 52
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 49,
+                            "column": 53
+                          },
+                          "end": {
+                            "line": 49,
+                            "column": 60
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 44
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 60
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 49,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 49,
+                    "column": 61
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 8
+                },
+                "end": {
+                  "line": 49,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 49,
+                "column": 5
+              },
+              "end": {
+                "line": 49,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 49,
+              "column": 5
+            },
+            "end": {
+              "line": 49,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 49,
+          "column": 1
+        },
+        "end": {
+          "line": 49,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "e",
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 9
+                  }
+                }
+              },
+              "typeParameters": {
+                "type": "TSTypeParameterInstantiation",
+                "params": [
+                  {
+                    "type": "TSFunctionType",
+                    "params": [],
+                    "typeParameters": {
+                      "type": "TSTypeParameterDeclaration",
+                      "params": [
+                        {
+                          "type": "TSTypeParameter",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "A",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 50,
+                                "column": 11
+                              },
+                              "end": {
+                                "line": 50,
+                                "column": 12
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 50,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 50,
+                              "column": 13
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 50,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 50,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "returnType": {
+                      "type": "TSTypeLiteral",
+                      "members": [],
+                      "loc": {
+                        "start": {
+                          "line": 50,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 50,
+                          "column": 21
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 50,
+                        "column": 10
+                      },
+                      "end": {
+                        "line": 50,
+                        "column": 21
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 50,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 50,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 8
+                },
+                "end": {
+                  "line": 50,
+                  "column": 9
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 50,
+                "column": 5
+              },
+              "end": {
+                "line": 50,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 50,
+              "column": 5
+            },
+            "end": {
+              "line": 50,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 50,
+          "column": 1
+        },
+        "end": {
+          "line": 50,
+          "column": 23
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "E",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 6
+          },
+          "end": {
+            "line": 52,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSUnionType",
+        "types": [
+          {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 38
+              },
+              "end": {
+                "line": 52,
+                "column": 44
+              }
+            }
+          },
+          {
+            "type": "TSTypeReference",
+            "typeName": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 47
+                },
+                "end": {
+                  "line": 52,
+                  "column": 48
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 47
+              },
+              "end": {
+                "line": 52,
+                "column": 48
+              }
+            }
+          },
+          {
+            "type": "TSStringKeyword",
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 51
+              },
+              "end": {
+                "line": 52,
+                "column": 57
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 38
+          },
+          "end": {
+            "line": 52,
+            "column": 57
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "R",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 8
+                },
+                "end": {
+                  "line": 52,
+                  "column": 9
+                }
+              }
+            },
+            "constraint": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "B",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 52,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 52,
+                    "column": 19
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 18
+                },
+                "end": {
+                  "line": 52,
+                  "column": 19
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 8
+              },
+              "end": {
+                "line": 52,
+                "column": 20
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 21
+                },
+                "end": {
+                  "line": 52,
+                  "column": 22
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 21
+              },
+              "end": {
+                "line": 52,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 24
+                },
+                "end": {
+                  "line": 52,
+                  "column": 25
+                }
+              }
+            },
+            "default": {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 52,
+                  "column": 28
+                },
+                "end": {
+                  "line": 52,
+                  "column": 34
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 52,
+                "column": 24
+              },
+              "end": {
+                "line": 52,
+                "column": 35
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 52,
+            "column": 7
+          },
+          "end": {
+            "line": 52,
+            "column": 35
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 52,
+          "column": 1
+        },
+        "end": {
+          "line": 52,
+          "column": 58
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 52,
+          "column": 57
+        },
+        "end": {
+          "line": 52,
+          "column": 58
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "P",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 53,
+            "column": 6
+          },
+          "end": {
+            "line": 53,
+            "column": 7
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "TSTypeLiteral",
+        "members": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 52
+                },
+                "end": {
+                  "line": 53,
+                  "column": 53
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "K",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 54
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 55
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 54
+                },
+                "end": {
+                  "line": 53,
+                  "column": 55
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 52
+              },
+              "end": {
+                "line": 53,
+                "column": 56
+              }
+            }
+          },
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 57
+                },
+                "end": {
+                  "line": 53,
+                  "column": 58
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSTypeReference",
+              "typeName": {
+                "type": "Identifier",
+                "name": "Q",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 53,
+                    "column": 59
+                  },
+                  "end": {
+                    "line": 53,
+                    "column": 60
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 59
+                },
+                "end": {
+                  "line": 53,
+                  "column": 60
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 57
+              },
+              "end": {
+                "line": 53,
+                "column": 61
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 53,
+            "column": 51
+          },
+          "end": {
+            "line": 53,
+            "column": 61
+          }
+        }
+      },
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "K",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 8
+                },
+                "end": {
+                  "line": 53,
+                  "column": 9
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 8
+              },
+              "end": {
+                "line": 53,
+                "column": 10
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "Q",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 11
+                },
+                "end": {
+                  "line": 53,
+                  "column": 12
+                }
+              }
+            },
+            "default": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSTupleType",
+                  "elementTypes": [
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 16
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 23
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSNumberKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 31
+                        }
+                      }
+                    },
+                    {
+                      "type": "TSStringKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 53,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 53,
+                          "column": 39
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 39
+                    }
+                  }
+                },
+                {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSAnyKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 53,
+                        "column": 42
+                      },
+                      "end": {
+                        "line": 53,
+                        "column": 45
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 53,
+                      "column": 42
+                    },
+                    "end": {
+                      "line": 53,
+                      "column": 47
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 53,
+                  "column": 15
+                },
+                "end": {
+                  "line": 53,
+                  "column": 47
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 53,
+                "column": 11
+              },
+              "end": {
+                "line": 53,
+                "column": 48
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 53,
+            "column": 7
+          },
+          "end": {
+            "line": 53,
+            "column": 48
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 53,
+          "column": 1
+        },
+        "end": {
+          "line": 53,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "EmptyStatement",
+      "loc": {
+        "start": {
+          "line": 53,
+          "column": 61
+        },
+        "end": {
+          "line": 53,
+          "column": 62
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "async",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 55,
+              "column": 1
+            },
+            "end": {
+              "line": 55,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "typeParameters": {
+          "type": "TSTypeParameterInstantiation",
+          "params": [
+            {
+              "type": "TSFunctionType",
+              "params": [],
+              "typeParameters": {
+                "type": "TSTypeParameterDeclaration",
+                "params": [
+                  {
+                    "type": "TSTypeParameter",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "A",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 55,
+                          "column": 8
+                        },
+                        "end": {
+                          "line": 55,
+                          "column": 9
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 55,
+                        "column": 8
+                      },
+                      "end": {
+                        "line": 55,
+                        "column": 10
+                      }
+                    }
+                  }
+                ],
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 10
+                  }
+                }
+              },
+              "returnType": {
+                "type": "TSTypeLiteral",
+                "members": [],
+                "loc": {
+                  "start": {
+                    "line": 55,
+                    "column": 16
+                  },
+                  "end": {
+                    "line": 55,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 55,
+                  "column": 7
+                },
+                "end": {
+                  "line": 55,
+                  "column": 18
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 55,
+              "column": 6
+            },
+            "end": {
+              "line": 55,
+              "column": 19
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 55,
+            "column": 1
+          },
+          "end": {
+            "line": 55,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 55,
+          "column": 1
+        },
+        "end": {
+          "line": 55,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "Identifier",
+          "name": "async",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 1
+            },
+            "end": {
+              "line": 56,
+              "column": 6
+            }
+          }
+        },
+        "arguments": [],
+        "optional": false,
+        "typeParameters": {
+          "type": "TSTypeParameterInstantiation",
+          "params": [
+            {
+              "type": "TSNumberKeyword",
+              "loc": {
+                "start": {
+                  "line": 56,
+                  "column": 7
+                },
+                "end": {
+                  "line": 56,
+                  "column": 13
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 56,
+              "column": 6
+            },
+            "end": {
+              "line": 56,
+              "column": 14
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 56,
+            "column": 1
+          },
+          "end": {
+            "line": 56,
+            "column": 16
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 56,
+          "column": 1
+        },
+        "end": {
+          "line": 56,
+          "column": 17
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": false,
+          "expression": true,
+          "params": [],
+          "returnType": {
+            "type": "TSNumberKeyword",
+            "loc": {
+              "start": {
+                "line": 57,
+                "column": 17
+              },
+              "end": {
+                "line": 57,
+                "column": 23
+              }
+            }
+          },
+          "typeParameters": {
+            "type": "TSTypeParameterDeclaration",
+            "params": [
+              {
+                "type": "TSTypeParameter",
+                "name": {
+                  "type": "Identifier",
+                  "name": "A",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 57,
+                      "column": 2
+                    },
+                    "end": {
+                      "line": 57,
+                      "column": 3
+                    }
+                  }
+                },
+                "constraint": {
+                  "type": "TSTypeReference",
+                  "typeName": {
+                    "type": "Identifier",
+                    "name": "B",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 57,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 57,
+                        "column": 13
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 57,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 57,
+                      "column": 13
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 57,
+                    "column": 2
+                  },
+                  "end": {
+                    "line": 57,
+                    "column": 14
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 57,
+                "column": 1
+              },
+              "end": {
+                "line": 57,
+                "column": 14
+              }
+            }
+          },
+          "body": {
+            "type": "BooleanLiteral",
+            "value": true,
+            "loc": {
+              "start": {
+                "line": 57,
+                "column": 27
+              },
+              "end": {
+                "line": 57,
+                "column": 31
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 1
+            },
+            "end": {
+              "line": 57,
+              "column": 31
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 57,
+            "column": 1
+          },
+          "end": {
+            "line": 57,
+            "column": 31
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 57,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "ExpressionStatement",
+      "expression": {
+        "type": "ArrowFunctionExpression",
+        "function": {
+          "type": "ScriptFunction",
+          "id": null,
+          "generator": false,
+          "async": true,
+          "expression": false,
+          "params": [],
+          "typeParameters": {
+            "type": "TSTypeParameterDeclaration",
+            "params": [
+              {
+                "type": "TSTypeParameter",
+                "name": {
+                  "type": "Identifier",
+                  "name": "A",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 7
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 8
+                    }
+                  }
+                },
+                "constraint": {
+                  "type": "TSTypeOperator",
+                  "operator": "readonly",
+                  "typeAnnotation": {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSNumberKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 58,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 58,
+                            "column": 34
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSStringKeyword",
+                        "loc": {
+                          "start": {
+                            "line": 58,
+                            "column": 35
+                          },
+                          "end": {
+                            "line": 58,
+                            "column": 42
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 58,
+                        "column": 26
+                      },
+                      "end": {
+                        "line": 58,
+                        "column": 42
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 42
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 7
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 43
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 6
+              },
+              "end": {
+                "line": 58,
+                "column": 43
+              }
+            }
+          },
+          "body": {
+            "type": "BlockStatement",
+            "statements": [
+              {
+                "type": "ReturnStatement",
+                "argument": {
+                  "type": "StringLiteral",
+                  "value": "",
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 57
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 62
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 58,
+                    "column": 50
+                  },
+                  "end": {
+                    "line": 58,
+                    "column": 63
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 58,
+                "column": 49
+              },
+              "end": {
+                "line": 58,
+                "column": 64
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 58,
+              "column": 1
+            },
+            "end": {
+              "line": 58,
+              "column": 64
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 58,
+            "column": 1
+          },
+          "end": {
+            "line": 58,
+            "column": 64
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 58,
+          "column": 1
+        },
+        "end": {
+          "line": 58,
+          "column": 65
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 58,
+      "column": 65
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test_generic.ts b/es2panda/test/parser/ts/test_generic.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fa831a127781a3b1f1a36270242347784a1a43a1
--- /dev/null
+++ b/es2panda/test/parser/ts/test_generic.ts
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function func1<Type, A, B extends readonly number[]>(arg: Type): Type {
+    return arg;
+}
+
+function func2<A extends { a: number, b: string }>() { }
+
+function func3<A extends keyof { a: { b: number, c: boolean }, b: [number, string] }>(a: A, b: string): number | boolean {
+    return true;
+}
+
+declare type PromiseConstructorLike = new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) => PromiseLike<T>;
+
+interface R<K extends [number, string], T = string> {
+    a: number,
+    [x: string]: boolean | number,
+}
+
+interface U<A extends readonly [number, number, { a: number, b: string }], Z = boolean> extends R<[number, string]> {
+    <A>(): number,
+    readonly<A extends number>(): [boolean, number[]];
+}
+
+func1<number, string, [1, 2, 3]>()
+func2<<A>() => {}>();
+
+var o = {
+    a: function <B, C extends typeof func1>() { },
+    b: function <D = number, T = string>() { },
+    c<E, F extends readonly []>() { }
+}
+
+class A<T extends B, Z = { a: number, b: string }> {
+    public a<T, R>() { };
+    private b<E extends (a: number, b: string) => any[]>() { }
+}
+
+class W extends T<<B> () => number, [number | string][]> {
+
+}
+
+class X extends Q<number> implements S<<R>(a:number, b:string) => [number]>, A {
+
+}
+
+var a: new <A>() => <B>() => string;
+var b: <A extends T, U = 5>(a: number | string) => { a: number };
+
+var c: B.T<A<C<number>>>[0];
+var d: A<number, { a: number, b: string }, [number, string]>;
+var e: T<<A>() => {}>;
+
+type E<R extends B, C, T = number> = number | T | string;
+type P<K, Q = [number, number, string] | any[]> = {a:K, b:Q};
+
+async<<A>() => {}>();
+async<number>();
+<A extends B>():number => true;
+async<A extends readonly [number, string]>() => {return "foo";};
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_import_type-expected.txt b/es2panda/test/parser/ts/test_import_type-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bff178a94ffca8b0e7e5b6e7d2784b12cb1e79e4
--- /dev/null
+++ b/es2panda/test/parser/ts/test_import_type-expected.txt
@@ -0,0 +1,839 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSImportType",
+              "parameter": {
+                "type": "TSLiteralType",
+                "literal": {
+                  "type": "StringLiteral",
+                  "value": "tar",
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 20
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 15
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 20
+                  }
+                }
+              },
+              "isTypeOf": false,
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 8
+                },
+                "end": {
+                  "line": 1,
+                  "column": 22
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 5
+              },
+              "end": {
+                "line": 1,
+                "column": 6
+              }
+            }
+          },
+          "init": null,
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 5
+            },
+            "end": {
+              "line": 1,
+              "column": 6
+            }
+          }
+        }
+      ],
+      "kind": "var",
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 22
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSMethodSignature",
+            "computed": false,
+            "optional": false,
+            "key": {
+              "type": "Identifier",
+              "name": "k",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 5
+                },
+                "end": {
+                  "line": 4,
+                  "column": 6
+                }
+              }
+            },
+            "params": [],
+            "typeAnnotation": {
+              "type": "TSImportType",
+              "parameter": {
+                "type": "TSLiteralType",
+                "literal": {
+                  "type": "StringLiteral",
+                  "value": "foo",
+                  "loc": {
+                    "start": {
+                      "line": 4,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 4,
+                      "column": 22
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 22
+                  }
+                }
+              },
+              "qualifier": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 4,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 4,
+                    "column": 25
+                  }
+                }
+              },
+              "isTypeOf": false,
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 10
+                },
+                "end": {
+                  "line": 4,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 4,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "TSIndexSignature",
+            "parameters": {
+              "type": "Identifier",
+              "name": "x",
+              "typeAnnotation": {
+                "type": "TSNumberKeyword",
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 15
+                  }
+                }
+              },
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 6
+                },
+                "end": {
+                  "line": 5,
+                  "column": 7
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSImportType",
+              "parameter": {
+                "type": "TSLiteralType",
+                "literal": {
+                  "type": "StringLiteral",
+                  "value": "baz",
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 37
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 32
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 37
+                  }
+                }
+              },
+              "qualifier": {
+                "type": "Identifier",
+                "name": "t",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 5,
+                    "column": 39
+                  },
+                  "end": {
+                    "line": 5,
+                    "column": 40
+                  }
+                }
+              },
+              "isTypeOf": true,
+              "loc": {
+                "start": {
+                  "line": 5,
+                  "column": 18
+                },
+                "end": {
+                  "line": 6,
+                  "column": 2
+                }
+              }
+            },
+            "readonly": false,
+            "loc": {
+              "start": {
+                "line": 5,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 13
+          },
+          "end": {
+            "line": 6,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "B",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 3,
+            "column": 11
+          },
+          "end": {
+            "line": 3,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 3,
+          "column": 1
+        },
+        "end": {
+          "line": 6,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "FunctionDeclaration",
+      "function": {
+        "type": "ScriptFunction",
+        "id": {
+          "type": "Identifier",
+          "name": "k",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 10
+            },
+            "end": {
+              "line": 8,
+              "column": 11
+            }
+          }
+        },
+        "generator": false,
+        "async": false,
+        "expression": false,
+        "params": [
+          {
+            "type": "Identifier",
+            "name": "a",
+            "typeAnnotation": {
+              "type": "TSImportType",
+              "parameter": {
+                "type": "TSLiteralType",
+                "literal": {
+                  "type": "StringLiteral",
+                  "value": "bar",
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 27
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 27
+                  }
+                }
+              },
+              "qualifier": {
+                "type": "TSQualifiedName",
+                "left": {
+                  "type": "TSQualifiedName",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "r",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 29
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 30
+                      }
+                    }
+                  },
+                  "right": {
+                    "type": "Identifier",
+                    "name": "t",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 31
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 32
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 32
+                    }
+                  }
+                },
+                "right": {
+                  "type": "Identifier",
+                  "name": "e",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 34
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 35
+                  }
+                }
+              },
+              "isTypeOf": false,
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 15
+                },
+                "end": {
+                  "line": 8,
+                  "column": 35
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 12
+              },
+              "end": {
+                "line": 8,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "returnType": {
+          "type": "TSImportType",
+          "parameter": {
+            "type": "TSLiteralType",
+            "literal": {
+              "type": "StringLiteral",
+              "value": "foo",
+              "loc": {
+                "start": {
+                  "line": 8,
+                  "column": 44
+                },
+                "end": {
+                  "line": 8,
+                  "column": 49
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 44
+              },
+              "end": {
+                "line": 8,
+                "column": 49
+              }
+            }
+          },
+          "typeParameters": {
+            "type": "TSTypeParameterInstantiation",
+            "params": [
+              {
+                "type": "TSFunctionType",
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "a",
+                    "typeAnnotation": {
+                      "type": "TSUnionType",
+                      "types": [
+                        {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 57
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 63
+                            }
+                          }
+                        },
+                        {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 66
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 72
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 72
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 55
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 56
+                      }
+                    }
+                  },
+                  {
+                    "type": "Identifier",
+                    "name": "b",
+                    "typeAnnotation": {
+                      "type": "TSImportType",
+                      "parameter": {
+                        "type": "TSLiteralType",
+                        "literal": {
+                          "type": "StringLiteral",
+                          "value": "a",
+                          "loc": {
+                            "start": {
+                              "line": 8,
+                              "column": 91
+                            },
+                            "end": {
+                              "line": 8,
+                              "column": 94
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 91
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 94
+                          }
+                        }
+                      },
+                      "typeParameters": {
+                        "type": "TSTypeParameterInstantiation",
+                        "params": [
+                          {
+                            "type": "TSTupleType",
+                            "elementTypes": [
+                              {
+                                "type": "TSNumberKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 8,
+                                    "column": 97
+                                  },
+                                  "end": {
+                                    "line": 8,
+                                    "column": 104
+                                  }
+                                }
+                              },
+                              {
+                                "type": "TSStringKeyword",
+                                "loc": {
+                                  "start": {
+                                    "line": 8,
+                                    "column": 105
+                                  },
+                                  "end": {
+                                    "line": 8,
+                                    "column": 112
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 8,
+                                "column": 96
+                              },
+                              "end": {
+                                "line": 8,
+                                "column": 112
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSTypeLiteral",
+                            "members": [],
+                            "loc": {
+                              "start": {
+                                "line": 8,
+                                "column": 114
+                              },
+                              "end": {
+                                "line": 8,
+                                "column": 116
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 95
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 117
+                          }
+                        }
+                      },
+                      "isTypeOf": true,
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 77
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 118
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 74
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 75
+                      }
+                    }
+                  }
+                ],
+                "typeParameters": {
+                  "type": "TSTypeParameterDeclaration",
+                  "params": [
+                    {
+                      "type": "TSTypeParameter",
+                      "name": {
+                        "type": "Identifier",
+                        "name": "A",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 8,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 8,
+                            "column": 53
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 8,
+                          "column": 52
+                        },
+                        "end": {
+                          "line": 8,
+                          "column": 54
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 51
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 54
+                    }
+                  }
+                },
+                "returnType": {
+                  "type": "TSArrayType",
+                  "elementType": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 8,
+                        "column": 122
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 128
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 8,
+                      "column": 122
+                    },
+                    "end": {
+                      "line": 8,
+                      "column": 130
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 8,
+                    "column": 51
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 130
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 8,
+                "column": 50
+              },
+              "end": {
+                "line": 8,
+                "column": 131
+              }
+            }
+          },
+          "isTypeOf": false,
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 37
+            },
+            "end": {
+              "line": 8,
+              "column": 133
+            }
+          }
+        },
+        "body": {
+          "type": "BlockStatement",
+          "statements": [],
+          "loc": {
+            "start": {
+              "line": 8,
+              "column": 132
+            },
+            "end": {
+              "line": 10,
+              "column": 2
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 8,
+            "column": 1
+          },
+          "end": {
+            "line": 10,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 10,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test_import_type.ts b/es2panda/test/parser/ts/test_import_type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4300268e7b50587e11cd235bba992e786a9ab40c
--- /dev/null
+++ b/es2panda/test/parser/ts/test_import_type.ts
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: import("tar");
+
+interface B {
+    k(): import("foo").b;
+    [x: number]: typeof import("baz").t
+}
+
+function k(a: import("bar").r.t.e): import("foo")<<A>(a:number | string, b: typeof import("a")<[number, string], {}>) => number[]> {
+    
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_module-expected.txt b/es2panda/test/parser/ts/test_module-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..26790b9ecac0e4644c365dea9c5a29efcc8d2b42
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module-expected.txt
@@ -0,0 +1,1886 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 12
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleBlock",
+        "body": [
+          {
+            "type": "VariableDeclaration",
+            "declarations": [
+              {
+                "type": "VariableDeclarator",
+                "id": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 10
+                    }
+                  }
+                },
+                "init": null,
+                "loc": {
+                  "start": {
+                    "line": 2,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 2,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "kind": "let",
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "TSInterfaceDeclaration",
+            "body": {
+              "type": "TSInterfaceBody",
+              "body": [
+                {
+                  "type": "TSPropertySignature",
+                  "computed": false,
+                  "optional": false,
+                  "readonly": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "typeAnnotation": {
+                    "type": "TSFunctionType",
+                    "params": [
+                      {
+                        "type": "Identifier",
+                        "name": "a",
+                        "typeAnnotation": {
+                          "type": "TSNumberKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 16
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 14
+                          }
+                        }
+                      },
+                      {
+                        "type": "Identifier",
+                        "name": "b",
+                        "typeAnnotation": {
+                          "type": "TSStringKeyword",
+                          "loc": {
+                            "start": {
+                              "line": 5,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 5,
+                              "column": 33
+                            }
+                          }
+                        },
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 5,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 5,
+                            "column": 25
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "TSBooleanKeyword",
+                      "loc": {
+                        "start": {
+                          "line": 5,
+                          "column": 38
+                        },
+                        "end": {
+                          "line": 5,
+                          "column": 45
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 5,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 5,
+                        "column": 45
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 5,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 5,
+                      "column": 46
+                    }
+                  }
+                },
+                {
+                  "type": "TSMethodSignature",
+                  "computed": false,
+                  "optional": false,
+                  "key": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "params": [],
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 20
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 7,
+                      "column": 6
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 17
+                },
+                "end": {
+                  "line": 7,
+                  "column": 6
+                }
+              }
+            },
+            "id": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 4,
+                  "column": 15
+                },
+                "end": {
+                  "line": 4,
+                  "column": 16
+                }
+              }
+            },
+            "extends": [],
+            "loc": {
+              "start": {
+                "line": 4,
+                "column": 5
+              },
+              "end": {
+                "line": 7,
+                "column": 6
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 13
+          },
+          "end": {
+            "line": 8,
+            "column": 2
+          }
+        }
+      },
+      "declare": false,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 11
+          },
+          "end": {
+            "line": 10,
+            "column": 12
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleBlock",
+        "body": [
+          {
+            "type": "VariableDeclaration",
+            "declarations": [
+              {
+                "type": "VariableDeclarator",
+                "id": {
+                  "type": "Identifier",
+                  "name": "a",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 11,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 11,
+                      "column": 10
+                    }
+                  }
+                },
+                "init": null,
+                "loc": {
+                  "start": {
+                    "line": 11,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 11,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "kind": "let",
+            "loc": {
+              "start": {
+                "line": 11,
+                "column": 5
+              },
+              "end": {
+                "line": 11,
+                "column": 11
+              }
+            }
+          },
+          {
+            "type": "FunctionDeclaration",
+            "function": {
+              "type": "ScriptFunction",
+              "id": {
+                "type": "Identifier",
+                "name": "b",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 15
+                  }
+                }
+              },
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 13,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 13,
+                    "column": 21
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 13,
+                  "column": 5
+                },
+                "end": {
+                  "line": 13,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 13,
+                "column": 5
+              },
+              "end": {
+                "line": 13,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 10,
+            "column": 13
+          },
+          "end": {
+            "line": 14,
+            "column": 2
+          }
+        }
+      },
+      "declare": false,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 10,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 8
+          },
+          "end": {
+            "line": 16,
+            "column": 9
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleDeclaration",
+        "id": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 10
+            },
+            "end": {
+              "line": 16,
+              "column": 11
+            }
+          }
+        },
+        "body": {
+          "type": "TSModuleDeclaration",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 12
+              },
+              "end": {
+                "line": 16,
+                "column": 13
+              }
+            }
+          },
+          "body": {
+            "type": "TSModuleBlock",
+            "body": [
+              {
+                "type": "VariableDeclaration",
+                "declarations": [
+                  {
+                    "type": "VariableDeclarator",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 10
+                        }
+                      }
+                    },
+                    "init": null,
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 10
+                      }
+                    }
+                  }
+                ],
+                "kind": "let",
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "FunctionDeclaration",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 19,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 19,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [],
+                    "loc": {
+                      "start": {
+                        "line": 19,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 19,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 14
+              },
+              "end": {
+                "line": 20,
+                "column": 2
+              }
+            }
+          },
+          "declare": false,
+          "global": false,
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 12
+            },
+            "end": {
+              "line": 23,
+              "column": 7
+            }
+          }
+        },
+        "declare": false,
+        "global": false,
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 10
+          },
+          "end": {
+            "line": 23,
+            "column": 7
+          }
+        }
+      },
+      "declare": false,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 23,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "a",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 8
+          },
+          "end": {
+            "line": 23,
+            "column": 9
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleDeclaration",
+        "id": {
+          "type": "Identifier",
+          "name": "b",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 10
+            },
+            "end": {
+              "line": 23,
+              "column": 11
+            }
+          }
+        },
+        "body": {
+          "type": "TSModuleDeclaration",
+          "id": {
+            "type": "Identifier",
+            "name": "c",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 12
+              },
+              "end": {
+                "line": 23,
+                "column": 13
+              }
+            }
+          },
+          "body": {
+            "type": "TSModuleBlock",
+            "body": [
+              {
+                "type": "VariableDeclaration",
+                "declarations": [
+                  {
+                    "type": "VariableDeclarator",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 9
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 10
+                        }
+                      }
+                    },
+                    "init": null,
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 10
+                      }
+                    }
+                  }
+                ],
+                "kind": "let",
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 11
+                  }
+                }
+              },
+              {
+                "type": "FunctionDeclaration",
+                "function": {
+                  "type": "ScriptFunction",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 15
+                      }
+                    }
+                  },
+                  "generator": false,
+                  "async": false,
+                  "expression": false,
+                  "params": [],
+                  "body": {
+                    "type": "BlockStatement",
+                    "statements": [],
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 18
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 21
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 5
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 21
+                  }
+                }
+              }
+            ],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 14
+              },
+              "end": {
+                "line": 27,
+                "column": 2
+              }
+            }
+          },
+          "declare": false,
+          "global": false,
+          "loc": {
+            "start": {
+              "line": 23,
+              "column": 12
+            },
+            "end": {
+              "line": 29,
+              "column": 8
+            }
+          }
+        },
+        "declare": false,
+        "global": false,
+        "loc": {
+          "start": {
+            "line": 23,
+            "column": 10
+          },
+          "end": {
+            "line": 29,
+            "column": 8
+          }
+        }
+      },
+      "declare": false,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 23,
+          "column": 1
+        },
+        "end": {
+          "line": 29,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "k",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 19
+          },
+          "end": {
+            "line": 29,
+            "column": 20
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleDeclaration",
+        "id": {
+          "type": "Identifier",
+          "name": "z",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 21
+            },
+            "end": {
+              "line": 29,
+              "column": 22
+            }
+          }
+        },
+        "body": {
+          "type": "TSModuleBlock",
+          "body": [],
+          "loc": {
+            "start": {
+              "line": 29,
+              "column": 23
+            },
+            "end": {
+              "line": 31,
+              "column": 2
+            }
+          }
+        },
+        "declare": false,
+        "global": false,
+        "loc": {
+          "start": {
+            "line": 29,
+            "column": 21
+          },
+          "end": {
+            "line": 33,
+            "column": 8
+          }
+        }
+      },
+      "declare": true,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 29,
+          "column": 9
+        },
+        "end": {
+          "line": 33,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "global",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 9
+          },
+          "end": {
+            "line": 33,
+            "column": 15
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleBlock",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 33,
+            "column": 16
+          },
+          "end": {
+            "line": 35,
+            "column": 2
+          }
+        }
+      },
+      "declare": true,
+      "global": true,
+      "loc": {
+        "start": {
+          "line": 33,
+          "column": 9
+        },
+        "end": {
+          "line": 37,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 37,
+            "column": 16
+          },
+          "end": {
+            "line": 37,
+            "column": 21
+          }
+        }
+      },
+      "declare": true,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 37,
+          "column": 9
+        },
+        "end": {
+          "line": 39,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExportNamedDeclaration",
+      "declaration": {
+        "type": "VariableDeclaration",
+        "declarations": [
+          {
+            "type": "VariableDeclarator",
+            "id": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 39,
+                  "column": 12
+                },
+                "end": {
+                  "line": 39,
+                  "column": 13
+                }
+              }
+            },
+            "init": null,
+            "loc": {
+              "start": {
+                "line": 39,
+                "column": 12
+              },
+              "end": {
+                "line": 39,
+                "column": 13
+              }
+            }
+          }
+        ],
+        "kind": "var",
+        "loc": {
+          "start": {
+            "line": 39,
+            "column": 8
+          },
+          "end": {
+            "line": 39,
+            "column": 14
+          }
+        }
+      },
+      "source": null,
+      "specifiers": [],
+      "loc": {
+        "start": {
+          "line": 39,
+          "column": 1
+        },
+        "end": {
+          "line": 39,
+          "column": 14
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "module1",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 8
+          },
+          "end": {
+            "line": 41,
+            "column": 15
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleBlock",
+        "body": [
+          {
+            "type": "ExportNamedDeclaration",
+            "declaration": {
+              "type": "VariableDeclaration",
+              "declarations": [
+                {
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "a",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 42,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 42,
+                        "column": 25
+                      }
+                    }
+                  },
+                  "init": null,
+                  "loc": {
+                    "start": {
+                      "line": 42,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 42,
+                      "column": 25
+                    }
+                  }
+                }
+              ],
+              "kind": "var",
+              "declare": true,
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 20
+                },
+                "end": {
+                  "line": 42,
+                  "column": 26
+                }
+              }
+            },
+            "source": null,
+            "specifiers": [],
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 5
+              },
+              "end": {
+                "line": 42,
+                "column": 26
+              }
+            }
+          },
+          {
+            "type": "VariableDeclaration",
+            "declarations": [
+              {
+                "type": "VariableDeclarator",
+                "id": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 43,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 43,
+                      "column": 18
+                    }
+                  }
+                },
+                "init": null,
+                "loc": {
+                  "start": {
+                    "line": 43,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 43,
+                    "column": 18
+                  }
+                }
+              }
+            ],
+            "kind": "var",
+            "declare": true,
+            "loc": {
+              "start": {
+                "line": 43,
+                "column": 13
+              },
+              "end": {
+                "line": 43,
+                "column": 19
+              }
+            }
+          },
+          {
+            "type": "VariableDeclaration",
+            "declarations": [
+              {
+                "type": "VariableDeclarator",
+                "id": {
+                  "type": "Identifier",
+                  "name": "c",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 44,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 10
+                    }
+                  }
+                },
+                "init": null,
+                "loc": {
+                  "start": {
+                    "line": 44,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "kind": "var",
+            "loc": {
+              "start": {
+                "line": 44,
+                "column": 5
+              },
+              "end": {
+                "line": 44,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 41,
+            "column": 16
+          },
+          "end": {
+            "line": 45,
+            "column": 2
+          }
+        }
+      },
+      "declare": false,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 41,
+          "column": 1
+        },
+        "end": {
+          "line": 47,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExportNamedDeclaration",
+      "declaration": {
+        "type": "TSModuleDeclaration",
+        "id": {
+          "type": "Identifier",
+          "name": "module2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 15
+            },
+            "end": {
+              "line": 47,
+              "column": 22
+            }
+          }
+        },
+        "body": {
+          "type": "TSModuleBlock",
+          "body": [
+            {
+              "type": "ExportNamedDeclaration",
+              "declaration": {
+                "type": "VariableDeclaration",
+                "declarations": [
+                  {
+                    "type": "VariableDeclarator",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 48,
+                          "column": 24
+                        },
+                        "end": {
+                          "line": 48,
+                          "column": 25
+                        }
+                      }
+                    },
+                    "init": null,
+                    "loc": {
+                      "start": {
+                        "line": 48,
+                        "column": 24
+                      },
+                      "end": {
+                        "line": 48,
+                        "column": 25
+                      }
+                    }
+                  }
+                ],
+                "kind": "var",
+                "declare": true,
+                "loc": {
+                  "start": {
+                    "line": 48,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 48,
+                    "column": 26
+                  }
+                }
+              },
+              "source": null,
+              "specifiers": [],
+              "loc": {
+                "start": {
+                  "line": 48,
+                  "column": 5
+                },
+                "end": {
+                  "line": 48,
+                  "column": 26
+                }
+              }
+            },
+            {
+              "type": "VariableDeclaration",
+              "declarations": [
+                {
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 49,
+                        "column": 17
+                      },
+                      "end": {
+                        "line": 49,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "init": null,
+                  "loc": {
+                    "start": {
+                      "line": 49,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 49,
+                      "column": 18
+                    }
+                  }
+                }
+              ],
+              "kind": "var",
+              "declare": true,
+              "loc": {
+                "start": {
+                  "line": 49,
+                  "column": 13
+                },
+                "end": {
+                  "line": 49,
+                  "column": 19
+                }
+              }
+            },
+            {
+              "type": "VariableDeclaration",
+              "declarations": [
+                {
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "c",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 50,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 50,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "init": null,
+                  "loc": {
+                    "start": {
+                      "line": 50,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 50,
+                      "column": 10
+                    }
+                  }
+                }
+              ],
+              "kind": "var",
+              "loc": {
+                "start": {
+                  "line": 50,
+                  "column": 5
+                },
+                "end": {
+                  "line": 50,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 47,
+              "column": 23
+            },
+            "end": {
+              "line": 51,
+              "column": 2
+            }
+          }
+        },
+        "declare": false,
+        "global": false,
+        "loc": {
+          "start": {
+            "line": 47,
+            "column": 8
+          },
+          "end": {
+            "line": 53,
+            "column": 8
+          }
+        }
+      },
+      "source": null,
+      "specifiers": [],
+      "loc": {
+        "start": {
+          "line": 47,
+          "column": 1
+        },
+        "end": {
+          "line": 53,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "module3",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 53,
+            "column": 16
+          },
+          "end": {
+            "line": 53,
+            "column": 23
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleBlock",
+        "body": [
+          {
+            "type": "VariableDeclaration",
+            "declarations": [
+              {
+                "type": "VariableDeclarator",
+                "id": {
+                  "type": "Identifier",
+                  "name": "b",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 54,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 54,
+                      "column": 10
+                    }
+                  }
+                },
+                "init": null,
+                "loc": {
+                  "start": {
+                    "line": 54,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 54,
+                    "column": 10
+                  }
+                }
+              }
+            ],
+            "kind": "var",
+            "loc": {
+              "start": {
+                "line": 54,
+                "column": 5
+              },
+              "end": {
+                "line": 54,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 53,
+            "column": 24
+          },
+          "end": {
+            "line": 55,
+            "column": 2
+          }
+        }
+      },
+      "declare": true,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 53,
+          "column": 9
+        },
+        "end": {
+          "line": 57,
+          "column": 7
+        }
+      }
+    },
+    {
+      "type": "ExportNamedDeclaration",
+      "declaration": {
+        "type": "TSModuleDeclaration",
+        "id": {
+          "type": "Identifier",
+          "name": "module4",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 23
+            },
+            "end": {
+              "line": 57,
+              "column": 30
+            }
+          }
+        },
+        "body": {
+          "type": "TSModuleBlock",
+          "body": [
+            {
+              "type": "VariableDeclaration",
+              "declarations": [
+                {
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 58,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 58,
+                        "column": 10
+                      }
+                    }
+                  },
+                  "init": null,
+                  "loc": {
+                    "start": {
+                      "line": 58,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 58,
+                      "column": 10
+                    }
+                  }
+                }
+              ],
+              "kind": "var",
+              "loc": {
+                "start": {
+                  "line": 58,
+                  "column": 5
+                },
+                "end": {
+                  "line": 58,
+                  "column": 11
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 57,
+              "column": 31
+            },
+            "end": {
+              "line": 59,
+              "column": 2
+            }
+          }
+        },
+        "declare": true,
+        "global": false,
+        "loc": {
+          "start": {
+            "line": 57,
+            "column": 16
+          },
+          "end": {
+            "line": 61,
+            "column": 8
+          }
+        }
+      },
+      "source": null,
+      "specifiers": [],
+      "loc": {
+        "start": {
+          "line": 57,
+          "column": 1
+        },
+        "end": {
+          "line": 61,
+          "column": 8
+        }
+      }
+    },
+    {
+      "type": "TSModuleDeclaration",
+      "id": {
+        "type": "StringLiteral",
+        "value": "",
+        "loc": {
+          "start": {
+            "line": 61,
+            "column": 16
+          },
+          "end": {
+            "line": 61,
+            "column": 21
+          }
+        }
+      },
+      "body": {
+        "type": "TSModuleBlock",
+        "body": [
+          {
+            "type": "TSImportEqualsDeclaration",
+            "id": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 19
+                },
+                "end": {
+                  "line": 62,
+                  "column": 20
+                }
+              }
+            },
+            "moduleReference": {
+              "type": "TSExternalModuleReference",
+              "expression": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 62,
+                    "column": 31
+                  },
+                  "end": {
+                    "line": 62,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 62,
+                  "column": 23
+                },
+                "end": {
+                  "line": 62,
+                  "column": 37
+                }
+              }
+            },
+            "isExport": true,
+            "loc": {
+              "start": {
+                "line": 62,
+                "column": 5
+              },
+              "end": {
+                "line": 62,
+                "column": 38
+              }
+            }
+          },
+          {
+            "type": "TSImportEqualsDeclaration",
+            "id": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 12
+                },
+                "end": {
+                  "line": 63,
+                  "column": 13
+                }
+              }
+            },
+            "moduleReference": {
+              "type": "TSExternalModuleReference",
+              "expression": {
+                "type": "StringLiteral",
+                "value": "",
+                "loc": {
+                  "start": {
+                    "line": 63,
+                    "column": 24
+                  },
+                  "end": {
+                    "line": 63,
+                    "column": 29
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 63,
+                  "column": 16
+                },
+                "end": {
+                  "line": 63,
+                  "column": 30
+                }
+              }
+            },
+            "isExport": false,
+            "loc": {
+              "start": {
+                "line": 63,
+                "column": 5
+              },
+              "end": {
+                "line": 63,
+                "column": 31
+              }
+            }
+          },
+          {
+            "type": "TSImportEqualsDeclaration",
+            "id": {
+              "type": "Identifier",
+              "name": "c",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 12
+                },
+                "end": {
+                  "line": 64,
+                  "column": 13
+                }
+              }
+            },
+            "moduleReference": {
+              "type": "Identifier",
+              "name": "require",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 64,
+                  "column": 16
+                },
+                "end": {
+                  "line": 64,
+                  "column": 23
+                }
+              }
+            },
+            "isExport": false,
+            "loc": {
+              "start": {
+                "line": 64,
+                "column": 5
+              },
+              "end": {
+                "line": 64,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 61,
+            "column": 22
+          },
+          "end": {
+            "line": 65,
+            "column": 2
+          }
+        }
+      },
+      "declare": true,
+      "global": false,
+      "loc": {
+        "start": {
+          "line": 61,
+          "column": 9
+        },
+        "end": {
+          "line": 65,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 65,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test_module.ts b/es2panda/test/parser/ts/test_module.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7bf4d582c864f0ba768749145faaffbfcc5a7e20
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module.ts
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+namespace a {
+    let a;
+
+    interface B {
+        a: (a: number, b: string) => boolean,
+        b(): number
+    }
+}
+
+namespace a {
+    let a;
+
+    function b() { }
+}
+
+module a.b.c {
+    let a;
+
+    function b() { }
+}
+
+
+module a.b.c {
+    let a;
+
+    function b() { }
+}
+
+declare namespace k.z {
+
+}
+
+declare global {
+
+}
+
+declare module "foo";
+
+export var c;
+
+module module1 {
+    export declare var a;
+    declare var b;
+    var c;
+}
+
+export module module2 {
+    export declare var a;
+    declare var b;
+    var c;
+}
+
+declare module module3 {
+    var b;
+}
+
+export declare module module4 {
+    var b;
+}
+
+declare module "foo" {
+    export import a = require("bar");
+    import b = require("bar");
+    import c = require;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_module1-expected.txt b/es2panda/test/parser/ts/test_module1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1ad2ef1f4c45899b2f3cab4d12cc6f573a15f47b
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A 'declare' modifier cannot be used in an already ambient context. [test_module1.ts:2:5]
diff --git a/es2panda/test/parser/ts/test_module1.ts b/es2panda/test/parser/ts/test_module1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1f389def9318c9548096af562ec3a4db47c1d81e
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module1.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare module Foo {
+    declare var a;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_module2-expected.txt b/es2panda/test/parser/ts/test_module2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..02e0d2b4fe1d7342dddf7f49f00e778ab7698385
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A 'declare' modifier cannot be used in an already ambient context. [test_module2.ts:2:5]
diff --git a/es2panda/test/parser/ts/test_module2.ts b/es2panda/test/parser/ts/test_module2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56da09d96d23533ec5d5ca9e9294e11e79a3beb6
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+export declare module Foo {
+    declare var a;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_module3-expected.txt b/es2panda/test/parser/ts/test_module3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d5307ce0f57c0f019f271d24a9252a1bc97b2803
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A 'declare' modifier cannot be used in an already ambient context. [test_module3.ts:2:12]
diff --git a/es2panda/test/parser/ts/test_module3.ts b/es2panda/test/parser/ts/test_module3.ts
new file mode 100644
index 0000000000000000000000000000000000000000..25a9f8732eaa487330f8896075ed20d658c4128d
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module3.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare module Foo {
+    export declare var a;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_module4-expected.txt b/es2panda/test/parser/ts/test_module4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c495ed3a31ca45f4b22b711581a0258bdb591571
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A 'declare' modifier cannot be used in an already ambient context. [test_module4.ts:2:12]
diff --git a/es2panda/test/parser/ts/test_module4.ts b/es2panda/test/parser/ts/test_module4.ts
new file mode 100644
index 0000000000000000000000000000000000000000..baeda6aea606fe9805e0fdab55f63001f4d767f4
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module4.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+export declare module Foo {
+    export declare var a;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_module5-expected.txt b/es2panda/test/parser/ts/test_module5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..672c8daafcfcec533a2744f0daf6ad04727e771b
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module5-expected.txt
@@ -0,0 +1 @@
+SyntaxError: String literal expected. [test_module5.ts:2:24]
diff --git a/es2panda/test/parser/ts/test_module5.ts b/es2panda/test/parser/ts/test_module5.ts
new file mode 100644
index 0000000000000000000000000000000000000000..14f781c4f668475ea8fa745ec205d35e4181f649
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module5.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare module "foo" {
+    import a = require(bar);
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_module6-expected.txt b/es2panda/test/parser/ts/test_module6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2a9a8d4616b39046f04d31e09a8b368d6be4c0f6
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module6-expected.txt
@@ -0,0 +1 @@
+SyntaxError: ')' expected. [test_module6.ts:2:29]
diff --git a/es2panda/test/parser/ts/test_module6.ts b/es2panda/test/parser/ts/test_module6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..01a295bd883a540e7217a2748bf23dbd929798c0
--- /dev/null
+++ b/es2panda/test/parser/ts/test_module6.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+declare module "foo" {
+    import a = require("bar"[0]);
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_this_type-expected.txt b/es2panda/test/parser/ts/test_this_type-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..904a3fbb4cef5a6d8481b805e219c393b4014571
--- /dev/null
+++ b/es2panda/test/parser/ts/test_this_type-expected.txt
@@ -0,0 +1,431 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "TSPropertySignature",
+            "computed": false,
+            "optional": false,
+            "readonly": false,
+            "key": {
+              "type": "Identifier",
+              "name": "a",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 5
+                },
+                "end": {
+                  "line": 2,
+                  "column": 6
+                }
+              }
+            },
+            "typeAnnotation": {
+              "type": "TSUnionType",
+              "types": [
+                {
+                  "type": "TSThisType",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 8
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 12
+                    }
+                  }
+                },
+                {
+                  "type": "TSNumberKeyword",
+                  "loc": {
+                    "start": {
+                      "line": 2,
+                      "column": 15
+                    },
+                    "end": {
+                      "line": 2,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "loc": {
+                "start": {
+                  "line": 2,
+                  "column": 8
+                },
+                "end": {
+                  "line": 2,
+                  "column": 21
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 2,
+                "column": 5
+              },
+              "end": {
+                "line": 2,
+                "column": 22
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 16
+          },
+          "end": {
+            "line": 3,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "alma",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 11
+          },
+          "end": {
+            "line": 1,
+            "column": 15
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 3,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 7
+            },
+            "end": {
+              "line": 5,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "constructor": {
+          "type": "MethodDefinition",
+          "key": {
+            "type": "Identifier",
+            "name": "constructor",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "kind": "constructor",
+          "static": false,
+          "optional": false,
+          "computed": false,
+          "value": {
+            "type": "FunctionExpression",
+            "function": {
+              "type": "ScriptFunction",
+              "id": null,
+              "generator": false,
+              "async": false,
+              "expression": false,
+              "params": [],
+              "body": {
+                "type": "BlockStatement",
+                "statements": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          "overloads": [],
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 5,
+              "column": 1
+            },
+            "end": {
+              "line": 7,
+              "column": 2
+            }
+          }
+        },
+        "body": [
+          {
+            "type": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "b",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 5
+                },
+                "end": {
+                  "line": 6,
+                  "column": 6
+                }
+              }
+            },
+            "static": false,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "TSFunctionType",
+              "params": [
+                {
+                  "type": "Identifier",
+                  "name": "a",
+                  "typeAnnotation": {
+                    "type": "TSNumberKeyword",
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 9
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 10
+                    }
+                  }
+                },
+                {
+                  "type": "Identifier",
+                  "name": "b",
+                  "typeAnnotation": {
+                    "type": "TSTupleType",
+                    "elementTypes": [
+                      {
+                        "type": "TSUnionType",
+                        "types": [
+                          {
+                            "type": "TSStringKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 6,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 6,
+                                "column": 30
+                              }
+                            }
+                          },
+                          {
+                            "type": "TSNumberKeyword",
+                            "loc": {
+                              "start": {
+                                "line": 6,
+                                "column": 33
+                              },
+                              "end": {
+                                "line": 6,
+                                "column": 39
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 24
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 40
+                          }
+                        }
+                      },
+                      {
+                        "type": "TSTypeLiteral",
+                        "members": [],
+                        "loc": {
+                          "start": {
+                            "line": 6,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 6,
+                            "column": 44
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 6,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 6,
+                        "column": 44
+                      }
+                    }
+                  },
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 6,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 6,
+                      "column": 21
+                    }
+                  }
+                }
+              ],
+              "returnType": {
+                "type": "TSThisType",
+                "loc": {
+                  "start": {
+                    "line": 6,
+                    "column": 49
+                  },
+                  "end": {
+                    "line": 6,
+                    "column": 53
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 6,
+                  "column": 8
+                },
+                "end": {
+                  "line": 6,
+                  "column": 53
+                }
+              }
+            },
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 6,
+                "column": 5
+              },
+              "end": {
+                "line": 6,
+                "column": 6
+              }
+            }
+          }
+        ],
+        "indexSignatures": [],
+        "loc": {
+          "start": {
+            "line": 5,
+            "column": 9
+          },
+          "end": {
+            "line": 7,
+            "column": 2
+          }
+        }
+      },
+      "decorators": [],
+      "loc": {
+        "start": {
+          "line": 5,
+          "column": 1
+        },
+        "end": {
+          "line": 7,
+          "column": 2
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 7,
+      "column": 2
+    }
+  }
+}
diff --git a/es2panda/test/parser/ts/test_this_type.ts b/es2panda/test/parser/ts/test_this_type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b8bf54706123a736f7a9452e268b0810cef93447
--- /dev/null
+++ b/es2panda/test/parser/ts/test_this_type.ts
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+interface alma {
+    a: this | number,
+}
+
+class A {
+    b: (a: number, b: [string | number, {}]) => this;
+}
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_this_type1-expected.txt b/es2panda/test/parser/ts/test_this_type1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6cfe2114e0b16c0c5e16e9be736f77ff69bba85f
--- /dev/null
+++ b/es2panda/test/parser/ts/test_this_type1-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A 'this' type is available only in a non-static member of a class or interface. [test_this_type1.ts:1:8]
diff --git a/es2panda/test/parser/ts/test_this_type1.ts b/es2panda/test/parser/ts/test_this_type1.ts
new file mode 100644
index 0000000000000000000000000000000000000000..693b272d0a0a9c10ff0cbb03d1d4ce55fdb892db
--- /dev/null
+++ b/es2panda/test/parser/ts/test_this_type1.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var a: this;
\ No newline at end of file
diff --git a/es2panda/test/parser/ts/test_this_type2-expected.txt b/es2panda/test/parser/ts/test_this_type2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8e1442fe4c5217bb63cf0d22cafc0bc421e87e60
--- /dev/null
+++ b/es2panda/test/parser/ts/test_this_type2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: A 'this' type is available only in a non-static member of a class or interface. [test_this_type2.ts:2:24]
diff --git a/es2panda/test/parser/ts/test_this_type2.ts b/es2panda/test/parser/ts/test_this_type2.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a0b18c106fbd86d0217e4caa213e09a12159ec53
--- /dev/null
+++ b/es2panda/test/parser/ts/test_this_type2.ts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+class A {
+    static a: number | this;
+}
\ No newline at end of file
diff --git a/es2panda/test/runner.py b/es2panda/test/runner.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6e542bd773cd8bd656e212cb1a130ac47566207
--- /dev/null
+++ b/es2panda/test/runner.py
@@ -0,0 +1,746 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from glob import glob
+from os import path
+from enum import Enum
+import argparse
+import fnmatch
+import multiprocessing
+import os
+import re
+import subprocess
+import sys
+import test262util
+
+
+def is_directory(parser, arg):
+    if not path.isdir(arg):
+        parser.error("The directory '%s' does not exist" % arg)
+
+    return path.abspath(arg)
+
+
+def is_file(parser, arg):
+    if not path.isfile(arg):
+        parser.error("The file '%s' does not exist" % arg)
+
+    return path.abspath(arg)
+
+
+def check_timeout(value):
+    ivalue = int(value)
+    if ivalue <= 0:
+        raise argparse.ArgumentTypeError(
+            "%s is an invalid timeout value" % value)
+    return ivalue
+
+
+def get_args():
+    parser = argparse.ArgumentParser(description="Regression test runner")
+    parser.add_argument(
+        'build_dir', type=lambda arg: is_directory(parser, arg),
+        help='panda build directory')
+    parser.add_argument(
+        '--test262', '-t', action='store_true', dest='test262', default=False,
+        help='run test262 tests')
+    parser.add_argument(
+        '--error', action='store_true', dest='error', default=False,
+        help='capture stderr')
+    parser.add_argument(
+        '--regression', '-r', action='store_true', dest='regression',
+        default=False, help='run regression tests')
+    parser.add_argument(
+        '--tsc', action='store_true', dest='tsc',
+        default=False, help='run tsc tests')
+    parser.add_argument(
+        '--no-progress', action='store_false', dest='progress', default=True,
+        help='don\'t show progress bar')
+    parser.add_argument(
+        '--no-skip', action='store_false', dest='skip', default=True,
+        help='don\'t use skiplists')
+    parser.add_argument(
+        '--update', action='store_true', dest='update', default=False,
+        help='update skiplist')
+    parser.add_argument(
+        '--no-run-gc-in-place', action='store_true', dest='no_gip', default=False,
+        help='enable --run-gc-in-place mode')
+    parser.add_argument(
+        '--filter', '-f', action='store', dest='filter',
+        default="*", help='test filter regexp')
+    parser.add_argument(
+        '--es2panda-timeout', type=check_timeout,
+        dest='es2panda_timeout', default=60, help='es2panda translator timeout')
+    parser.add_argument(
+        '--paoc-timeout', type=check_timeout,
+        dest='paoc_timeout', default=600, help='paoc compiler timeout')
+    parser.add_argument(
+        '--timeout', type=check_timeout,
+        dest='timeout', default=10, help='JS runtime timeout')
+    parser.add_argument(
+        '--gc-type', dest='gc_type', default="g1-gc", help='Type of garbage collector')
+    parser.add_argument(
+        '--aot', action='store_true', dest='aot', default=False,
+        help='use AOT compilation')
+    parser.add_argument(
+        '--no-bco', action='store_false', dest='bco', default=True,
+        help='disable bytecodeopt')
+    parser.add_argument(
+        '--jit', action='store_true', dest='jit', default=False,
+        help='use JIT in interpreter')
+    parser.add_argument(
+        '--arm64-compiler-skip', action='store_true', dest='arm64_compiler_skip', default=False,
+        help='use skiplist for tests failing on aarch64 in AOT or JIT mode')
+    parser.add_argument(
+        '--arm64-qemu', action='store_true', dest='arm64_qemu', default=False,
+        help='launch all binaries in qemu aarch64')
+    parser.add_argument(
+        '--arm32-qemu', action='store_true', dest='arm32_qemu', default=False,
+        help='launch all binaries in qemu arm')
+    parser.add_argument(
+        '--test-list', dest='test_list', default=None, type=lambda arg: is_file(parser, arg),
+        help='run tests listed in file')
+    parser.add_argument(
+        '--aot-args', action='append', dest='aot_args', default=[],
+        help='Additional arguments that will passed to ark_aot')
+    parser.add_argument(
+        '--verbose', '-v', action='store_true', dest='verbose', default=False,
+        help='Enable verbose output')
+
+    return parser.parse_args()
+
+
+class Test:
+    def __init__(self, test_path, flags):
+        self.path = test_path
+        self.flags = flags
+        self.output = None
+        self.error = None
+        self.passed = None
+        self.skipped = None
+        self.reproduce = ""
+
+    def log_cmd(self, cmd):
+        self.reproduce += "\n" + ' '.join(cmd)
+
+    def run(self, runner):
+        cmd = runner.cmd_prefix + [runner.es2panda, "--dump-ast"]
+        cmd.extend(self.flags)
+        cmd.append(self.path)
+
+        self.log_cmd(cmd)
+        process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, err = process.communicate()
+        self.output = out.decode("utf-8", errors="ignore")
+
+        expected_path = "%s-expected.txt" % (path.splitext(self.path)[0])
+        try:
+            with open(expected_path, 'r') as fp:
+                expected = fp.read()
+            self.passed = expected == self.output and process.returncode in [
+                0, 1]
+        except Exception:
+            self.passed = False
+
+        if not self.passed:
+            self.error = err.decode("utf-8", errors="ignore")
+
+        return self
+
+
+class Test262Test(Test):
+    def __init__(self, test_path, flags, test_id, with_optimizer):
+        Test.__init__(self, test_path, flags)
+        self.test_id = test_id
+        self.fail_kind = None
+        self.with_optimizer = with_optimizer
+
+    class FailKind(Enum):
+        ES2PANDA_FAIL = 1
+        RUNTIME_FAIL = 2
+        AOT_FAIL = 3
+        ES2PANDA_TIMEOUT = 4
+        RUNTIME_TIMEOUT = 5
+        AOT_TIMEOUT = 6
+
+    def run(self, runner):
+        with open(self.path, 'r') as fp:
+            header = runner.util.get_header(fp.read())
+        desc = runner.util.parse_descriptor(header)
+
+        test_abc = path.join(runner.tmp_dir, "%s.abc" % self.test_id)
+        test_an = path.join(runner.tmp_dir, "%s.an" % self.test_id)
+
+        directory = path.dirname(test_abc)
+        os.makedirs(directory, exist_ok=True)
+
+        cmd = runner.cmd_prefix + [runner.es2panda]
+        if self.with_optimizer:
+            cmd.append('--opt-level=2')
+        cmd.extend(['--thread=0', '--output=%s' % (test_abc)])
+
+        if 'module' in desc['flags']:
+            cmd.append("--module")
+
+        if 'noStrict' in desc['flags']:
+            self.skipped = True
+            return self
+
+        cmd.append(self.path)
+
+        self.log_cmd(cmd)
+
+        if runner.args.verbose:
+            print('Run es2panda: %s' % ' '.join(cmd), file=sys.stderr)
+
+        process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=runner.cmd_env)
+
+        try:
+            out, err = process.communicate(runner.args.es2panda_timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.passed = False
+            self.fail_kind = self.FailKind.ES2PANDA_TIMEOUT
+            self.error = self.fail_kind.name
+            return self
+
+        out = out.decode("utf-8", errors="ignore")
+        err = err.decode("utf-8", errors="ignore")
+        self.passed, need_exec = runner.util.validate_parse_result(
+            process.returncode, err, desc, out)
+
+        if not self.passed:
+            self.fail_kind = self.FailKind.ES2PANDA_FAIL
+            self.error = "out:{}\nerr:{}\ncode:{}".format(
+                out, err, process.returncode)
+            return self
+
+        if not need_exec:
+            self.passed = True
+            return self
+
+        if runner.args.aot:
+            cmd = runner.cmd_prefix + [runner.arkaot]
+            cmd.extend(runner.aot_args)
+            cmd.extend(['--paoc-panda-files', test_abc])
+            cmd.extend(['--paoc-output', test_an])
+
+            if os.path.isfile(test_an):
+                os.remove(test_an)
+
+            self.log_cmd(cmd)
+
+            if runner.args.verbose:
+                print('Run ark_aot: %s' % ' '.join(cmd), file=sys.stderr)
+
+            process = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=runner.cmd_env)
+
+            try:
+                out, err = process.communicate(runner.args.paoc_timeout)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                self.passed = False
+                self.fail_kind = self.FailKind.AOT_TIMEOUT
+                self.error = self.fail_kind.name
+                return self
+
+            if process.returncode != 0:
+                self.passed = False
+                self.fail_kind = self.FailKind.AOT_FAIL
+                self.error = err.decode("utf-8", errors="ignore")
+                return self
+
+        cmd = runner.cmd_prefix + [runner.runtime]
+
+        if runner.args.verbose:
+            print('Run aot for arm64: %s' % ' '.join(cmd), file=sys.stderr)
+
+        cmd.extend(runner.runtime_args)
+
+        if runner.args.aot:
+            cmd.extend(['--aot-files', test_an])
+
+        if runner.args.jit:
+            cmd.extend(['--compiler-enable-jit=true', '--compiler-hotness-threshold=0'])
+        else:
+            cmd.extend(['--compiler-enable-jit=false'])
+
+        cmd.extend([test_abc, "_GLOBAL::func_main_0"])
+
+        self.log_cmd(cmd)
+
+        if runner.args.verbose:
+            print('Run ark: %s' % ' '.join(cmd), file=sys.stderr)
+
+        process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=runner.cmd_env)
+
+        try:
+            out, err = process.communicate(timeout=runner.args.timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.passed = False
+            self.fail_kind = self.FailKind.RUNTIME_TIMEOUT
+            self.error = self.fail_kind.name
+            return self
+
+        out = out.decode("utf-8", errors="ignore")
+        err = err.decode("utf-8", errors="ignore")
+        self.passed = runner.util.validate_runtime_result(
+            process.returncode, err, desc, out)
+
+        if not self.passed:
+            self.fail_kind = self.FailKind.RUNTIME_FAIL
+            self.error = "out:{}\nerr:{}\ncode:{}".format(
+                out, err, process.returncode)
+
+        return self
+
+
+class TSCTest(Test):
+    def __init__(self, test_path, flags):
+        Test.__init__(self, test_path, flags)
+        self.options = self.parse_options()
+
+    def parse_options(self):
+        test_options = {}
+
+        with open(self.path, "r", encoding="latin1") as f:
+            lines = f.read()
+            options = re.findall(r"//\s?@\w+:.*\n", lines)
+
+            for option in options:
+                separated = option.split(":")
+                opt = re.findall(r"\w+", separated[0])[0].lower()
+                value = separated[1].strip().lower()
+
+                if opt == "filename":
+                    if opt in options:
+                        test_options[opt].append(value)
+                    else:
+                        test_options[opt] = [value]
+
+                elif opt == "lib" or opt == "module":
+                    test_options[opt] = [each.strip()
+                                         for each in value.split(",")]
+                elif value == "true" or value == "false":
+                    test_options[opt] = value.lower() == "true"
+                else:
+                    test_options[opt] = value
+
+            # TODO: Possibility of error: all exports will be catched, even the commented ones
+            if 'module' not in test_options and re.search(r"export ", lines):
+                test_options['module'] = []
+
+        return test_options
+
+    def run(self, runner):
+        cmd = runner.cmd_prefix + [runner.es2panda, '--parse-only', '--extension=ts']
+        cmd.extend(self.flags)
+        if "module" in self.options:
+            cmd.append('--module')
+        cmd.append(self.path)
+
+        self.log_cmd(cmd)
+        process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, err = process.communicate()
+        self.output = out.decode("utf-8", errors="ignore")
+
+        self.passed = True if process.returncode == 0 else False
+
+        if not self.passed:
+            self.error = err.decode("utf-8", errors="ignore")
+
+        return self
+
+
+class Runner:
+    def __init__(self, args, name):
+        self.test_root = path.dirname(path.abspath(__file__))
+        self.args = args
+        self.name = name
+        self.tests = []
+        self.failed = 0
+        self.passed = 0
+        self.es2panda = path.join(args.build_dir, 'bin', 'es2panda')
+        self.cmd_prefix = []
+
+        if args.arm64_qemu:
+            self.cmd_prefix = ["qemu-aarch64", "-L", "/usr/aarch64-linux-gnu/"]
+
+        if args.arm32_qemu:
+            self.cmd_prefix = ["qemu-arm", "-L", "/usr/arm-linux-gnueabi"]
+
+        if not path.isfile(self.es2panda):
+            raise Exception("Cannot find es2panda binary: %s" % self.es2panda)
+
+    def add_directory(self, directory, extension, flags):
+        pass
+
+    def test_path(self, src):
+        pass
+
+    def run_test(self, test):
+        return test.run(self)
+
+    def run(self):
+        pool = multiprocessing.Pool()
+        result_iter = pool.imap_unordered(
+            self.run_test, self.tests, chunksize=32)
+        pool.close()
+
+        if self.args.progress:
+            from tqdm import tqdm
+            result_iter = tqdm(result_iter, total=len(self.tests))
+
+        results = []
+        for res in result_iter:
+            results.append(res)
+
+        self.tests = results
+        pool.join()
+
+    def summarize(self):
+        print("")
+        fail_list = []
+
+        for test in self.tests:
+            assert(test.passed is not None)
+            if not test.passed:
+                fail_list.append(test)
+
+        if len(fail_list):
+            print("Failed tests:")
+            for test in fail_list:
+                print(self.test_path(test.path))
+
+                if self.args.error:
+                    print("steps:", test.reproduce)
+                    print(test.error)
+
+            print("")
+
+        print("Summary(%s):" % self.name)
+        print("\033[37mTotal:   %5d" % (len(self.tests)))
+        print("\033[92mPassed:  %5d" % (len(self.tests) - len(fail_list)))
+        print("\033[91mFailed:  %5d" % (len(fail_list)))
+        print("\033[0m")
+
+        return len(fail_list)
+
+
+class RegressionRunner(Runner):
+    def __init__(self, args):
+        Runner.__init__(self, args, "Regresssion")
+
+    def add_directory(self, directory, extension, flags):
+        glob_expression = path.join(
+            self.test_root, directory, "*.%s" % (extension))
+        files = glob(glob_expression)
+        files = fnmatch.filter(files, self.test_root + '**' + self.args.filter)
+
+        self.tests += list(map(lambda f: Test(f, flags), files))
+
+    def test_path(self, src):
+        return src
+
+
+class Test262Runner(Runner):
+    def __init__(self, args):
+        Runner.__init__(self, args, "Test262 ark"),
+
+        self.cmd_env = os.environ.copy()
+        for san in ["ASAN_OPTIONS", "TSAN_OPTIONS", "MSAN_OPTIONS", "LSAN_OPTIONS"]:
+            # we don't want to interpret asan failures as SyntaxErrors
+            self.cmd_env[san] = ":exitcode=255"
+
+        self.update = args.update
+        self.enable_skiplists = False if self.update else args.skip
+        self.normal_skiplist_file = "test262skiplist.txt"
+        self.long_flaky_skiplist_files = ["test262skiplist-long.txt", "test262skiplist-flaky.txt"]
+        self.normal_skiplist = set([])
+        self.runtime = path.join(args.build_dir, 'bin', 'ark')
+        if not path.isfile(self.runtime):
+            raise Exception("Cannot find runtime binary: %s" % self.runtime)
+
+        self.runtime_args = [
+            '--boot-panda-files=%s/pandastdlib/arkstdlib.abc'
+            % args.build_dir,
+            '--load-runtimes=ecmascript',
+            '--gc-type=%s' % args.gc_type,
+        ]
+
+        if not args.no_gip:
+            self.runtime_args += ['--run-gc-in-place']
+
+        if args.aot:
+            self.arkaot = path.join(args.build_dir, 'bin', 'ark_aot')
+            if not path.isfile(self.arkaot):
+                raise Exception("Cannot find aot binary: %s" % self.arkaot)
+
+            self.aot_args = [
+                '--boot-panda-files=%s/pandastdlib/arkstdlib.abc'
+                % args.build_dir,
+                '--load-runtimes=ecmascript',
+                '--gc-type=%s' % args.gc_type,
+            ]
+
+            if not args.no_gip:
+                self.aot_args += ['--run-gc-in-place']
+
+            self.aot_args += args.aot_args
+        else:
+            self.aot_args = []
+
+        self.skiplist_name_list = self.long_flaky_skiplist_files if self.update else []
+        self.skiplist_bco_name = ""
+
+        if self.enable_skiplists:
+            self.skiplist_name_list.append(self.normal_skiplist_file)
+            self.skiplist_name_list.extend(self.long_flaky_skiplist_files)
+
+            if args.bco:
+                self.skiplist_bco_name = "test262skiplist-bco.txt"
+            if args.arm64_compiler_skip:
+                self.skiplist_name_list.append("test262skiplist-compiler-arm64.txt")
+
+        self.tmp_dir = path.join(path.sep, 'tmp', 'panda', 'test262')
+        os.makedirs(self.tmp_dir, exist_ok=True)
+
+        self.util = test262util.Test262Util()
+        self.test262_dir = self.util.generate(
+            '281eb10b2844929a7c0ac04527f5b42ce56509fd',
+            args.build_dir,
+            path.join(self.test_root, "test262harness.js"),
+            args.progress)
+
+        self.add_directory(self.test262_dir, "js", args.test_list, [])
+
+    def add_directory(self, directory, extension, test_list_path, flags):
+        glob_expression = path.join(directory, "**/*.%s" % (extension))
+        files = glob(glob_expression, recursive=True)
+        files = fnmatch.filter(files, path.join(directory, self.args.filter))
+
+        def load_list(p):
+            with open(p, 'r') as fp:
+                return set(map(lambda e: path.join(directory, e.strip()), fp))
+
+        skiplist = set([])
+
+        for sl in self.skiplist_name_list:
+            skiplist.update(load_list(path.join(self.test_root, sl)))
+
+        if self.update:
+            self.normal_skiplist.update(load_list(path.join(self.test_root, self.normal_skiplist_file)))
+
+        skiplist_bco = set([])
+        if self.skiplist_bco_name != "":
+            skiplist_bco = load_list(path.join(self.test_root, self.skiplist_bco_name))
+
+        if test_list_path is not None:
+            test_list = load_list(path.abspath(test_list_path))
+            files = filter(lambda f: f in test_list, files)
+
+        def get_test_id(file):
+            return path.relpath(path.splitext(file)[0], self.test262_dir)
+
+        self.tests = list(map(lambda test: Test262Test(test, flags, get_test_id(test), test not in skiplist_bco),
+                              filter(lambda f: f not in skiplist, files)))
+
+    def test_path(self, src):
+        return path.relpath(src, self.test262_dir)
+
+    def run(self):
+        Runner.run(self)
+        self.update_skiplist()
+
+    def summarize(self):
+        print("")
+
+        fail_lists = {}
+        for kind in Test262Test.FailKind:
+            fail_lists[kind] = []
+
+        num_failed = 0
+        num_skipped = 0
+        for test in self.tests:
+            if test.skipped:
+                num_skipped += 1
+                continue
+
+            assert(test.passed is not None)
+            if not test.passed:
+                fail_lists[test.fail_kind].append(test)
+                num_failed += 1
+
+        def summarize_list(name, tests_list):
+            if len(tests_list):
+                tests_list.sort(key=lambda test: test.path)
+                print("# " + name)
+                for test in tests_list:
+                    print(self.test_path(test.path))
+                    if self.args.error:
+                        print("steps:", test.reproduce)
+                        print(test.error)
+                print("")
+
+        total_tests = len(self.tests) - num_skipped
+
+        if not self.update:
+            for kind in Test262Test.FailKind:
+                summarize_list(kind.name, fail_lists[kind])
+
+        print("Summary(%s):" % self.name)
+        print("\033[37mTotal:   %5d" % (total_tests))
+        print("\033[92mPassed:  %5d" % (total_tests - num_failed))
+        print("\033[91mFailed:  %5d" % (num_failed))
+        print("\033[0m")
+
+        return num_failed
+
+    def update_skiplist(self):
+        if not self.update:
+            return
+
+        skiplist_es2panda = list({x.test_id + ".js" for x in self.tests
+                                  if not x.skipped and not x.passed and
+                                  x.fail_kind == Test262Test.FailKind.ES2PANDA_FAIL})
+        skiplist_runtime = list({x.test_id + ".js" for x in self.tests
+                                 if not x.skipped and not x.passed and
+                                 x.fail_kind == Test262Test.FailKind.RUNTIME_FAIL})
+
+        skiplist_es2panda.sort()
+        skiplist_runtime.sort()
+
+        new_skiplist = skiplist_es2panda + skiplist_runtime
+
+        new_pass = list(filter(lambda x: len(x) and not x.startswith('#')
+                               and x not in new_skiplist, self.normal_skiplist))
+        new_fail = list(filter(lambda x: x not in self.normal_skiplist, new_skiplist))
+        new_pass.sort()
+        new_fail.sort()
+
+        if new_pass:
+            print("\033[92mRemoved from skiplist:")
+            print("\n".join(new_pass))
+            print("\033[0m")
+
+        if new_fail:
+            print("\033[91mNew tests on skiplist:")
+            print("\n".join(new_fail))
+            print("\033[0m")
+
+        fd = os.open(path.join(self.test_root, self.normal_skiplist_file), os.O_RDWR | os.O_CREAT | os.O_TRUNC)
+        file = os.fdopen(fd, "w+")
+        file.write("\n".join(["# ES2PANDA_FAIL"] + skiplist_es2panda + ["", "# RUNTIME_FAIL"] + skiplist_runtime))
+        file.write("\n")
+        file.close()
+
+
+class TSCRunner(Runner):
+    def __init__(self, args):
+        Runner.__init__(self, args, "TSC")
+
+        ts_dir = path.join(self.test_root, "TypeScript")
+        ts_branch = "v4.2.4"
+
+        if not path.isdir(ts_dir):
+            subprocess.run(
+                f"git clone https://github.com/microsoft/TypeScript.git \
+                {ts_dir} && cd {ts_dir} \
+                && git checkout {ts_branch} > /dev/null 2>&1",
+                shell=True,
+                stdout=subprocess.DEVNULL,
+            )
+        else:
+            subprocess.run(
+                f"cd {ts_dir} && git clean -f > /dev/null 2>&1",
+                shell=True,
+                stdout=subprocess.DEVNULL,
+            )
+
+        self.add_directory("conformance", [])
+        self.add_directory("compiler", [])
+
+    def add_directory(self, directory, flags):
+        ts_suite_dir = path.join(self.test_root, 'TypeScript/tests/cases')
+
+        glob_expression = path.join(
+            ts_suite_dir, directory, "**/*.ts")
+        files = glob(glob_expression, recursive=True)
+        files = fnmatch.filter(files, ts_suite_dir + '**' + self.args.filter)
+
+        for f in files:
+            test_name = path.basename(f.split(".ts")[0])
+            negative_references = path.join(
+                self.test_root, 'TypeScript/tests/baselines/reference')
+            is_negative = path.isfile(path.join(negative_references,
+                                                test_name + ".errors.txt"))
+            test = TSCTest(f, flags)
+
+            if 'target' in test.options:
+                targets = test.options['target'].replace(" ", "").split(',')
+                for target in targets:
+                    if path.isfile(path.join(negative_references,
+                                             test_name + "(target=%s).errors.txt" % (target))):
+                        is_negative = True
+                        break
+
+            if is_negative or "filename" in test.options:
+                continue
+
+            self.tests.append(test)
+
+    def test_path(self, src):
+        return src
+
+
+def main():
+    args = get_args()
+
+    runners = []
+
+    if args.regression:
+        runner = RegressionRunner(args)
+        runner.add_directory("parser/js", "js", ["--parse-only"])
+        # TODO(aszilagyi): reenable TS tests
+        # runner.add_directory("parser/ts", "ts",
+        #                      ["--parse-only", '--extension=ts'])
+        # runner.add_directory("compiler/ts", "ts", ["--extension=ts", ])
+
+        runners.append(runner)
+
+    if args.test262:
+        runners.append(Test262Runner(args))
+
+    if args.tsc:
+        runners.append(TSCRunner(args))
+
+    failed_tests = 0
+
+    for runner in runners:
+        runner.run()
+        failed_tests += runner.summarize()
+
+    exit(0 if failed_tests == 0 else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/es2panda/test/test262harness.js b/es2panda/test/test262harness.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d6d2685acf7f1e53ec472b26ddf135a65e0b6a6
--- /dev/null
+++ b/es2panda/test/test262harness.js
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!globalThis.$262) {
+    globalThis.$262 = {
+        global: globalThis,
+        evalScript(code) {
+            try {
+                global.evalScript(code);
+                return { type: 'normal', value: undefined };
+            } catch (e) {
+                return { type: 'throw', value: e };
+            }
+        },
+        gc() {
+            throw new Test262Error('gc() not yet supported.');
+        },
+        getGlobal(name) {
+            return global[name];
+        },
+        setGlobal(name, value) {
+            global[name] = value;
+        },
+        agent: (function () {
+            function thrower() {
+                throw new Test262Error('agent.* not yet supported.');
+            };
+            return {
+                start: thrower,
+                broadcast: thrower,
+                getReport: thrower,
+                sleep: thrower,
+                monotonicNow: thrower,
+            };
+        })(),
+    };
+}
+
+$262.IsHTMLDDA = function () { };
+$262.destroy = function () { };
+$262.getGlobal = function (name) {
+    return this.global[name];
+};
+$262.setGlobal = function (name, value) {
+    this.global[name] = value;
+};
+$262.source = $SOURCE;
diff --git a/es2panda/test/test262skiplist-bco.txt b/es2panda/test/test262skiplist-bco.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/es2panda/test/test262skiplist-compiler-arm64.txt b/es2panda/test/test262skiplist-compiler-arm64.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cf29d31b09671ba1cc4ff3c1630fd4db84b23d0a
--- /dev/null
+++ b/es2panda/test/test262skiplist-compiler-arm64.txt
@@ -0,0 +1,388 @@
+annexB/built-ins/Proxy/set/call-parameters-prototype-dunder-proto.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-11.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-12.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-14.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-3.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-5.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-7.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-8.js
+built-ins/Array/prototype/reduce/15.4.4.21-1-9.js
+built-ins/Array/prototype/reduce/15.4.4.21-10-1.js
+built-ins/Array/prototype/reduce/15.4.4.21-10-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-10-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-10-5.js
+built-ins/Array/prototype/reduce/15.4.4.21-10-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-10-7.js
+built-ins/Array/prototype/reduce/15.4.4.21-10-8.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-1.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-10.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-17.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-18.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-19.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-3.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-5.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-7.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-8.js
+built-ins/Array/prototype/reduce/15.4.4.21-2-9.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-11.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-13.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-15.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-16.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-17.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-19.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-20.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-21.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-23.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-24.js
+built-ins/Array/prototype/reduce/15.4.4.21-3-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-4-12.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-3.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-1.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-10.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-11.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-12.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-13.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-14.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-15.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-16.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-17.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-18.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-19.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-20.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-21.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-22.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-25.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-26.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-27.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-28.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-29.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-3.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-30.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-31.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-5.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-7.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-8.js
+built-ins/Array/prototype/reduce/15.4.4.21-8-b-iii-1-9.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-1.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-10.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-3.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-7.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-9.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-10.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-11.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-12.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-13.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-14.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-15.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-16.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-17.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-18.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-19.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-20.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-21.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-22.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-23.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-24.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-25.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-26.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-27.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-28.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-29.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-3.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-5.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-7.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-8.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-b-9.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-1.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-1.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-10.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-11.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-12.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-13.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-14.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-15.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-16.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-17.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-18.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-19.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-20.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-21.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-22.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-25.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-26.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-27.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-28.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-29.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-3.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-30.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-31.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-32.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-33.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-5.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-6.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-7.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-8.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-i-9.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-1.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-10.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-11.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-13.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-16.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-17.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-19.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-2.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-20.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-21.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-22.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-23.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-24.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-25.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-26.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-27.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-28.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-29.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-30.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-31.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-32.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-33.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-34.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-35.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-37.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-4-s.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-4.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-5.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-8.js
+built-ins/Array/prototype/reduce/15.4.4.21-9-c-ii-9.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-11.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-12.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-14.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-3.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-5.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-7.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-8.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-1-9.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-10-1.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-10-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-10-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-10-5.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-10-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-10-7.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-10-8.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-1.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-10.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-17.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-18.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-19.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-3.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-5.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-7.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-8.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-2-9.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-11.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-13.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-15.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-16.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-17.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-19.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-20.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-21.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-23.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-24.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-3-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-4-12.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-3.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-1.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-10.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-11.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-12.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-13.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-14.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-15.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-16.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-17.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-18.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-19.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-20.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-21.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-22.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-25.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-26.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-27.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-28.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-29.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-3.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-30.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-31.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-5.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-7.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-8.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-8-b-iii-1-9.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-1.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-3.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-7.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-9.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-10.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-11.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-12.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-13.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-14.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-15.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-16.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-17.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-18.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-19.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-20.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-21.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-22.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-23.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-24.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-25.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-26.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-27.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-28.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-29.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-3.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-5.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-7.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-8.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-b-9.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-1.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-1.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-10.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-11.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-12.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-13.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-14.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-15.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-16.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-17.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-18.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-19.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-20.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-21.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-22.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-25.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-26.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-27.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-28.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-29.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-3.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-30.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-31.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-32.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-33.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-5.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-6.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-7.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-8.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-i-9.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-1.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-10.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-11.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-13.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-16.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-17.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-18.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-19.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-2.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-20.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-21.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-22.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-23.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-24.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-25.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-26.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-27.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-28.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-29.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-30.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-31.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-32.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-33.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-34.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-35.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-37.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-4-s.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-4.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-5.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-8.js
+built-ins/Array/prototype/reduceRight/15.4.4.22-9-c-ii-9.js
+built-ins/Array/prototype/sort/stability-11-elements.js
+built-ins/Array/prototype/sort/stability-5-elements.js
+built-ins/Proxy/set/boolean-trap-result-is-false-boolean-return-false.js
+built-ins/Proxy/set/boolean-trap-result-is-false-null-return-false.js
+built-ins/Proxy/set/boolean-trap-result-is-false-number-return-false.js
+built-ins/Proxy/set/boolean-trap-result-is-false-string-return-false.js
+built-ins/Proxy/set/boolean-trap-result-is-false-undefined-return-false.js
+built-ins/Proxy/set/call-parameters-prototype-index.js
+built-ins/Proxy/set/call-parameters-prototype.js
+built-ins/Proxy/set/call-parameters.js
+built-ins/Proxy/set/return-true-target-property-accessor-is-configurable-set-is-undefined.js
+built-ins/Proxy/set/return-true-target-property-accessor-is-not-configurable.js
+built-ins/Proxy/set/return-true-target-property-is-not-configurable.js
+built-ins/Proxy/set/return-true-target-property-is-not-writable.js
+built-ins/Proxy/set/target-property-is-accessor-not-configurable-set-is-undefined.js
+built-ins/Proxy/set/target-property-is-not-configurable-not-writable-not-equal-to-v.js
+built-ins/Proxy/set/trap-is-undefined-target-is-proxy.js
+built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-end.js
+built-ins/TypedArray/prototype/copyWithin/negative-out-of-bounds-target.js
+built-ins/TypedArray/prototype/fill/coerced-indexes.js
+built-ins/TypedArray/prototype/fill/fill-values-conversion-operations.js
+built-ins/TypedArray/prototype/join/custom-separator-result-from-tostring-on-each-value.js
+built-ins/TypedArray/prototype/reduce/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/reduce/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/reduce/result-is-last-callbackfn-return.js
+built-ins/TypedArray/prototype/reduce/result-of-any-type.js
+built-ins/TypedArray/prototype/reduceRight/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/reduceRight/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/reduceRight/result-is-last-callbackfn-return.js
+built-ins/TypedArray/prototype/reduceRight/result-of-any-type.js
+built-ins/TypedArray/prototype/set/array-arg-offset-tointeger.js
+built-ins/TypedArray/prototype/set/array-arg-set-values.js
+built-ins/TypedArray/prototype/set/array-arg-src-tonumber-value-conversions.js
+built-ins/TypedArray/prototype/set/typedarray-arg-offset-tointeger.js
+built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type.js
+built-ins/TypedArray/prototype/slice/results-with-same-length.js
+built-ins/TypedArray/prototype/slice/tointeger-end.js
+built-ins/TypedArray/prototype/some/returns-false-if-every-cb-returns-false.js
+built-ins/TypedArray/prototype/subarray/results-with-different-length.js
+built-ins/TypedArray/prototype/subarray/tointeger-begin.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/key-is-not-canonical-index.js
+built-ins/TypedArrayConstructors/internals/Set/key-is-not-canonical-index.js
+language/expressions/bitwise-not/S9.5_A2.2_T2.js
+language/types/reference/put-value-prop-base-primitive.js
\ No newline at end of file
diff --git a/es2panda/test/test262skiplist-flaky.txt b/es2panda/test/test262skiplist-flaky.txt
new file mode 100644
index 0000000000000000000000000000000000000000..424e218b251d543bfae325fe2ff8870bce908cbb
--- /dev/null
+++ b/es2panda/test/test262skiplist-flaky.txt
@@ -0,0 +1,10 @@
+# Locale
+intl402/NumberFormat/test-option-localeMatcher.js
+intl402/RelativeTimeFormat/constructor/constructor/options-throwing-getters.js
+
+# panda#6907
+intl402/Locale/constructor-options-language-valid.js
+# panda#6927
+built-ins/TypedArray/prototype/filter/callbackfn-called-before-species.js
+# panda#6937
+intl402/NumberFormat/test-option-currencyDisplay.js
diff --git a/es2panda/test/test262skiplist-long.txt b/es2panda/test/test262skiplist-long.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ec8ef6c053960a41af62410488f1deb6806ea35b
--- /dev/null
+++ b/es2panda/test/test262skiplist-long.txt
@@ -0,0 +1,93 @@
+# RUNTIME-TIMEOUT
+built-ins/Array/prototype/concat/Array.prototype.concat_large-typed-array.js
+built-ins/Array/prototype/concat/Array.prototype.concat_small-typed-array.js
+built-ins/Array/prototype/every/15.4.4.16-7-c-ii-2.js
+built-ins/Array/prototype/filter/15.4.4.20-9-c-ii-1.js
+built-ins/Array/prototype/forEach/15.4.4.18-7-c-ii-1.js
+built-ins/Array/prototype/indexOf/15.4.4.14-10-1.js
+built-ins/Array/prototype/lastIndexOf/15.4.4.15-9-1.js
+built-ins/Array/prototype/map/15.4.4.19-8-c-ii-1.js
+built-ins/Array/prototype/some/15.4.4.17-7-c-ii-2.js
+built-ins/Array/prototype/sort/stability-2048-elements.js
+built-ins/Array/prototype/sort/stability-513-elements.js
+built-ins/Date/parse/time-value-maximum-range.js
+built-ins/Date/prototype/getTimezoneOffset/this-value-valid-date.js
+built-ins/Date/prototype/setFullYear/new-value-time-clip.js
+built-ins/Date/prototype/setHours/new-value-time-clip.js
+built-ins/Date/prototype/setMinutes/new-value-time-clip.js
+built-ins/Date/prototype/setMonth/new-value-time-clip.js
+built-ins/Date/prototype/setSeconds/new-value-time-clip.js
+built-ins/Date/prototype/toUTCString/month-names.js
+built-ins/RegExp/S15.10.2_A1_T1.js
+built-ins/RegExp/character-class-escape-non-whitespace.js
+built-ins/String/prototype/repeat/repeat-string-n-times.js
+built-ins/TypedArray/prototype/map/return-new-typedarray-conversion-operation.js
+built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type-conversions.js
+built-ins/TypedArray/prototype/sort/stability.js
+built-ins/decodeURI/S15.1.3.1_A1.10_T1.js
+built-ins/decodeURI/S15.1.3.1_A1.11_T1.js
+built-ins/decodeURI/S15.1.3.1_A1.11_T2.js
+built-ins/decodeURI/S15.1.3.1_A1.12_T1.js
+built-ins/decodeURI/S15.1.3.1_A1.12_T2.js
+built-ins/decodeURI/S15.1.3.1_A1.12_T3.js
+built-ins/decodeURI/S15.1.3.1_A1.13_T1.js
+built-ins/decodeURI/S15.1.3.1_A1.13_T2.js
+built-ins/decodeURI/S15.1.3.1_A1.14_T1.js
+built-ins/decodeURI/S15.1.3.1_A1.14_T2.js
+built-ins/decodeURI/S15.1.3.1_A1.14_T3.js
+built-ins/decodeURI/S15.1.3.1_A1.14_T4.js
+built-ins/decodeURI/S15.1.3.1_A1.15_T1.js
+built-ins/decodeURI/S15.1.3.1_A1.15_T2.js
+built-ins/decodeURI/S15.1.3.1_A1.15_T3.js
+built-ins/decodeURI/S15.1.3.1_A1.2_T1.js
+built-ins/decodeURI/S15.1.3.1_A1.2_T2.js
+built-ins/decodeURI/S15.1.3.1_A2.1_T1.js
+built-ins/decodeURI/S15.1.3.1_A2.3_T1.js
+built-ins/decodeURI/S15.1.3.1_A2.4_T1.js
+built-ins/decodeURI/S15.1.3.1_A2.5_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.10_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.11_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.11_T2.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.12_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.12_T2.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.12_T3.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.13_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.13_T2.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.14_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.14_T2.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.14_T3.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.14_T4.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.15_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.15_T2.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.15_T3.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.2_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A1.2_T2.js
+built-ins/decodeURIComponent/S15.1.3.2_A2.1_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A2.3_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A2.4_T1.js
+built-ins/decodeURIComponent/S15.1.3.2_A2.5_T1.js
+built-ins/encodeURI/S15.1.3.3_A1.1_T1.js
+built-ins/encodeURI/S15.1.3.3_A1.1_T2.js
+built-ins/encodeURI/S15.1.3.3_A1.2_T1.js
+built-ins/encodeURI/S15.1.3.3_A1.2_T2.js
+built-ins/encodeURI/S15.1.3.3_A1.3_T1.js
+built-ins/encodeURI/S15.1.3.3_A2.2_T1.js
+built-ins/encodeURI/S15.1.3.3_A2.3_T1.js
+built-ins/encodeURI/S15.1.3.3_A2.4_T1.js
+built-ins/encodeURI/S15.1.3.3_A2.4_T2.js
+built-ins/encodeURI/S15.1.3.3_A2.5_T1.js
+built-ins/encodeURIComponent/S15.1.3.4_A1.1_T1.js
+built-ins/encodeURIComponent/S15.1.3.4_A1.1_T2.js
+built-ins/encodeURIComponent/S15.1.3.4_A1.2_T1.js
+built-ins/encodeURIComponent/S15.1.3.4_A1.2_T2.js
+built-ins/encodeURIComponent/S15.1.3.4_A1.3_T1.js
+built-ins/encodeURIComponent/S15.1.3.4_A2.2_T1.js
+built-ins/encodeURIComponent/S15.1.3.4_A2.3_T1.js
+built-ins/encodeURIComponent/S15.1.3.4_A2.4_T1.js
+built-ins/encodeURIComponent/S15.1.3.4_A2.4_T2.js
+built-ins/encodeURIComponent/S15.1.3.4_A2.5_T1.js
+built-ins/parseFloat/S15.1.2.3_A6.js
+built-ins/parseInt/S15.1.2.2_A8.js
+intl402/Intl/getCanonicalLocales/invalid-tags.js
+intl402/Intl/getCanonicalLocales/transformed-ext-valid.js
+intl402/Locale/invalid-tag-throws.js
diff --git a/es2panda/test/test262skiplist.txt b/es2panda/test/test262skiplist.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d3eaf41c0c3e40a8fa1a18eda74b194c23f04833
--- /dev/null
+++ b/es2panda/test/test262skiplist.txt
@@ -0,0 +1,8981 @@
+# ES2PANDA_FAIL
+annexB/built-ins/RegExp/RegExp-decimal-escape-class-range.js
+annexB/built-ins/RegExp/incomplete_hex_unicode_escape.js
+annexB/language/comments/multi-line-html-close.js
+annexB/language/comments/single-line-html-close-asi.js
+annexB/language/comments/single-line-html-close-unicode-separators.js
+annexB/language/comments/single-line-html-close.js
+annexB/language/comments/single-line-html-open.js
+annexB/language/literals/regexp/class-escape.js
+built-ins/Atomics/add/bigint/bad-range.js
+built-ins/Atomics/add/bigint/good-views.js
+built-ins/Atomics/add/bigint/non-shared-bufferdata.js
+built-ins/Atomics/and/bigint/bad-range.js
+built-ins/Atomics/and/bigint/good-views.js
+built-ins/Atomics/and/bigint/non-shared-bufferdata.js
+built-ins/Atomics/compareExchange/bigint/bad-range.js
+built-ins/Atomics/compareExchange/bigint/good-views.js
+built-ins/Atomics/compareExchange/bigint/non-shared-bufferdata.js
+built-ins/Atomics/exchange/bigint/bad-range.js
+built-ins/Atomics/exchange/bigint/good-views.js
+built-ins/Atomics/exchange/bigint/non-shared-bufferdata.js
+built-ins/Atomics/load/bigint/good-views.js
+built-ins/Atomics/load/bigint/non-shared-bufferdata.js
+built-ins/Atomics/notify/bigint/notify-all-on-loc.js
+built-ins/Atomics/or/bigint/bad-range.js
+built-ins/Atomics/or/bigint/good-views.js
+built-ins/Atomics/or/bigint/non-shared-bufferdata.js
+built-ins/Atomics/store/bigint/bad-range.js
+built-ins/Atomics/store/bigint/good-views.js
+built-ins/Atomics/store/bigint/non-shared-bufferdata.js
+built-ins/Atomics/sub/bigint/bad-range.js
+built-ins/Atomics/sub/bigint/good-views.js
+built-ins/Atomics/sub/bigint/non-shared-bufferdata.js
+built-ins/Atomics/wait/bigint/bad-range.js
+built-ins/Atomics/wait/bigint/cannot-suspend-throws.js
+built-ins/Atomics/wait/bigint/false-for-timeout-agent.js
+built-ins/Atomics/wait/bigint/false-for-timeout.js
+built-ins/Atomics/wait/bigint/nan-for-timeout.js
+built-ins/Atomics/wait/bigint/negative-timeout-agent.js
+built-ins/Atomics/wait/bigint/negative-timeout.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-no-operation.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-add.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-and.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-compareExchange.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-exchange.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-or.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-store.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-sub.js
+built-ins/Atomics/wait/bigint/no-spurious-wakeup-on-xor.js
+built-ins/Atomics/wait/bigint/non-bigint64-typedarray-throws.js
+built-ins/Atomics/wait/bigint/non-shared-bufferdata-throws.js
+built-ins/Atomics/wait/bigint/value-not-equal.js
+built-ins/Atomics/wait/bigint/waiterlist-order-of-operations-is-fifo.js
+built-ins/Atomics/wait/bigint/was-woken-before-timeout.js
+built-ins/Atomics/waitAsync/bigint/bad-range.js
+built-ins/Atomics/waitAsync/bigint/false-for-timeout-agent.js
+built-ins/Atomics/waitAsync/bigint/false-for-timeout.js
+built-ins/Atomics/waitAsync/bigint/nan-for-timeout-agent.js
+built-ins/Atomics/waitAsync/bigint/negative-timeout-agent.js
+built-ins/Atomics/waitAsync/bigint/negative-timeout.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-no-operation.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-add.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-and.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-compareExchange.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-exchange.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-or.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-store.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-sub.js
+built-ins/Atomics/waitAsync/bigint/no-spurious-wakeup-on-xor.js
+built-ins/Atomics/waitAsync/bigint/non-shared-bufferdata-throws.js
+built-ins/Atomics/waitAsync/bigint/not-a-typedarray-throws.js
+built-ins/Atomics/waitAsync/bigint/null-for-timeout-agent.js
+built-ins/Atomics/waitAsync/bigint/null-for-timeout.js
+built-ins/Atomics/waitAsync/bigint/object-for-timeout-agent.js
+built-ins/Atomics/waitAsync/bigint/object-for-timeout.js
+built-ins/Atomics/waitAsync/bigint/poisoned-object-for-timeout-throws-agent.js
+built-ins/Atomics/waitAsync/bigint/poisoned-object-for-timeout-throws.js
+built-ins/Atomics/waitAsync/bigint/symbol-for-index-throws-agent.js
+built-ins/Atomics/waitAsync/bigint/symbol-for-timeout-throws-agent.js
+built-ins/Atomics/waitAsync/bigint/symbol-for-timeout-throws.js
+built-ins/Atomics/waitAsync/bigint/symbol-for-value-throws-agent.js
+built-ins/Atomics/waitAsync/bigint/true-for-timeout-agent.js
+built-ins/Atomics/waitAsync/bigint/true-for-timeout.js
+built-ins/Atomics/waitAsync/bigint/undefined-for-timeout.js
+built-ins/Atomics/waitAsync/bigint/value-not-equal-agent.js
+built-ins/Atomics/waitAsync/bigint/value-not-equal.js
+built-ins/Atomics/waitAsync/bigint/was-woken-before-timeout.js
+built-ins/Atomics/xor/bigint/good-views.js
+built-ins/Atomics/xor/bigint/non-shared-bufferdata.js
+built-ins/BigInt/asIntN/arithmetic.js
+built-ins/BigInt/asIntN/bigint-tobigint-toprimitive.js
+built-ins/BigInt/asIntN/bigint-tobigint-wrapped-values.js
+built-ins/BigInt/asIntN/bigint-tobigint.js
+built-ins/BigInt/asIntN/bits-toindex-errors.js
+built-ins/BigInt/asIntN/bits-toindex-toprimitive.js
+built-ins/BigInt/asIntN/bits-toindex-wrapped-values.js
+built-ins/BigInt/asIntN/bits-toindex.js
+built-ins/BigInt/asIntN/order-of-steps.js
+built-ins/BigInt/asUintN/arithmetic.js
+built-ins/BigInt/asUintN/bigint-tobigint-toprimitive.js
+built-ins/BigInt/asUintN/bigint-tobigint-wrapped-values.js
+built-ins/BigInt/asUintN/bigint-tobigint.js
+built-ins/BigInt/asUintN/bits-toindex-errors.js
+built-ins/BigInt/asUintN/bits-toindex-toprimitive.js
+built-ins/BigInt/asUintN/bits-toindex-wrapped-values.js
+built-ins/BigInt/asUintN/bits-toindex.js
+built-ins/BigInt/asUintN/order-of-steps.js
+built-ins/BigInt/call-value-of-when-to-string-present.js
+built-ins/BigInt/constructor-empty-string.js
+built-ins/BigInt/constructor-from-binary-string.js
+built-ins/BigInt/constructor-from-decimal-string.js
+built-ins/BigInt/constructor-from-hex-string.js
+built-ins/BigInt/constructor-from-octal-string.js
+built-ins/BigInt/constructor-integer.js
+built-ins/BigInt/constructor-trailing-leading-spaces.js
+built-ins/BigInt/prototype/toString/a-z.js
+built-ins/BigInt/prototype/toString/default-radix.js
+built-ins/BigInt/prototype/toString/radix-2-to-36.js
+built-ins/BigInt/prototype/toString/radix-err.js
+built-ins/BigInt/prototype/toString/string-is-code-units-of-decimal-digits-only.js
+built-ins/BigInt/prototype/toString/thisbigintvalue-not-valid-throws.js
+built-ins/BigInt/prototype/valueOf/cross-realm.js
+built-ins/BigInt/prototype/valueOf/return.js
+built-ins/DataView/prototype/getBigInt64/return-value-clean-arraybuffer.js
+built-ins/DataView/prototype/getBigInt64/return-values-custom-offset.js
+built-ins/DataView/prototype/getBigInt64/return-values.js
+built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js
+built-ins/DataView/prototype/getBigInt64/toindex-byteoffset-errors.js
+built-ins/DataView/prototype/getBigInt64/toindex-byteoffset-toprimitive.js
+built-ins/DataView/prototype/getBigInt64/toindex-byteoffset-wrapped-values.js
+built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js
+built-ins/DataView/prototype/getBigUint64/return-value-clean-arraybuffer.js
+built-ins/DataView/prototype/getBigUint64/return-values-custom-offset.js
+built-ins/DataView/prototype/getBigUint64/return-values.js
+built-ins/DataView/prototype/getBigUint64/to-boolean-littleendian.js
+built-ins/DataView/prototype/getBigUint64/toindex-byteoffset-errors.js
+built-ins/DataView/prototype/getBigUint64/toindex-byteoffset-toprimitive.js
+built-ins/DataView/prototype/getBigUint64/toindex-byteoffset-wrapped-values.js
+built-ins/DataView/prototype/getBigUint64/toindex-byteoffset.js
+built-ins/DataView/prototype/setBigInt64/detached-buffer.js
+built-ins/DataView/prototype/setBigInt64/index-is-out-of-range.js
+built-ins/DataView/prototype/setBigInt64/negative-byteoffset-throws.js
+built-ins/DataView/prototype/setBigInt64/return-abrupt-from-tonumber-byteoffset-symbol.js
+built-ins/DataView/prototype/setBigInt64/return-abrupt-from-tonumber-byteoffset.js
+built-ins/DataView/prototype/setBigInt64/set-values-little-endian-order.js
+built-ins/DataView/prototype/setBigInt64/to-boolean-littleendian.js
+built-ins/DataView/prototype/setBigInt64/toindex-byteoffset.js
+built-ins/Function/prototype/toString/private-method-class-expression.js
+built-ins/Function/prototype/toString/private-method-class-statement.js
+built-ins/Function/prototype/toString/private-static-method-class-expression.js
+built-ins/Function/prototype/toString/private-static-method-class-statement.js
+built-ins/JSON/stringify/value-bigint-order.js
+built-ins/JSON/stringify/value-bigint-replacer.js
+built-ins/JSON/stringify/value-bigint-tojson-receiver.js
+built-ins/JSON/stringify/value-bigint-tojson.js
+built-ins/JSON/stringify/value-bigint.js
+built-ins/Number/bigint-conversion.js
+built-ins/Object/bigint.js
+built-ins/Object/create/properties-arg-to-object-bigint.js
+built-ins/Object/prototype/toString/Object.prototype.toString.call-bigint.js
+built-ins/Object/setPrototypeOf/bigint.js
+built-ins/RegExp/named-groups/non-unicode-property-names-valid.js
+built-ins/RegExp/named-groups/non-unicode-references.js
+built-ins/RegExp/named-groups/unicode-property-names.js
+built-ins/RegExp/named-groups/unicode-references.js
+built-ins/RegExp/property-escapes/character-class.js
+built-ins/RegExp/property-escapes/generated/ASCII.js
+built-ins/RegExp/property-escapes/generated/ASCII_Hex_Digit.js
+built-ins/RegExp/property-escapes/generated/Alphabetic.js
+built-ins/RegExp/property-escapes/generated/Any.js
+built-ins/RegExp/property-escapes/generated/Assigned.js
+built-ins/RegExp/property-escapes/generated/Bidi_Control.js
+built-ins/RegExp/property-escapes/generated/Bidi_Mirrored.js
+built-ins/RegExp/property-escapes/generated/Case_Ignorable.js
+built-ins/RegExp/property-escapes/generated/Cased.js
+built-ins/RegExp/property-escapes/generated/Changes_When_Casefolded.js
+built-ins/RegExp/property-escapes/generated/Changes_When_Casemapped.js
+built-ins/RegExp/property-escapes/generated/Changes_When_Lowercased.js
+built-ins/RegExp/property-escapes/generated/Changes_When_NFKC_Casefolded.js
+built-ins/RegExp/property-escapes/generated/Changes_When_Titlecased.js
+built-ins/RegExp/property-escapes/generated/Changes_When_Uppercased.js
+built-ins/RegExp/property-escapes/generated/Dash.js
+built-ins/RegExp/property-escapes/generated/Default_Ignorable_Code_Point.js
+built-ins/RegExp/property-escapes/generated/Deprecated.js
+built-ins/RegExp/property-escapes/generated/Diacritic.js
+built-ins/RegExp/property-escapes/generated/Emoji.js
+built-ins/RegExp/property-escapes/generated/Emoji_Component.js
+built-ins/RegExp/property-escapes/generated/Emoji_Modifier.js
+built-ins/RegExp/property-escapes/generated/Emoji_Modifier_Base.js
+built-ins/RegExp/property-escapes/generated/Emoji_Presentation.js
+built-ins/RegExp/property-escapes/generated/Extended_Pictographic.js
+built-ins/RegExp/property-escapes/generated/Extender.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Cased_Letter.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Close_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Connector_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Control.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Currency_Symbol.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Dash_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Enclosing_Mark.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Final_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Format.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Initial_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Letter.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Letter_Number.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Line_Separator.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Lowercase_Letter.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Mark.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Math_Symbol.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Modifier_Letter.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Modifier_Symbol.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Nonspacing_Mark.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Number.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Open_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Other.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Letter.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Number.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Other_Symbol.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Paragraph_Separator.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Private_Use.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Punctuation.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Separator.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Space_Separator.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Spacing_Mark.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Surrogate.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Symbol.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Titlecase_Letter.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Unassigned.js
+built-ins/RegExp/property-escapes/generated/General_Category_-_Uppercase_Letter.js
+built-ins/RegExp/property-escapes/generated/Grapheme_Base.js
+built-ins/RegExp/property-escapes/generated/Grapheme_Extend.js
+built-ins/RegExp/property-escapes/generated/Hex_Digit.js
+built-ins/RegExp/property-escapes/generated/IDS_Binary_Operator.js
+built-ins/RegExp/property-escapes/generated/IDS_Trinary_Operator.js
+built-ins/RegExp/property-escapes/generated/ID_Continue.js
+built-ins/RegExp/property-escapes/generated/ID_Start.js
+built-ins/RegExp/property-escapes/generated/Ideographic.js
+built-ins/RegExp/property-escapes/generated/Join_Control.js
+built-ins/RegExp/property-escapes/generated/Logical_Order_Exception.js
+built-ins/RegExp/property-escapes/generated/Lowercase.js
+built-ins/RegExp/property-escapes/generated/Math.js
+built-ins/RegExp/property-escapes/generated/Noncharacter_Code_Point.js
+built-ins/RegExp/property-escapes/generated/Pattern_Syntax.js
+built-ins/RegExp/property-escapes/generated/Pattern_White_Space.js
+built-ins/RegExp/property-escapes/generated/Quotation_Mark.js
+built-ins/RegExp/property-escapes/generated/Radical.js
+built-ins/RegExp/property-escapes/generated/Regional_Indicator.js
+built-ins/RegExp/property-escapes/generated/Script_-_Adlam.js
+built-ins/RegExp/property-escapes/generated/Script_-_Ahom.js
+built-ins/RegExp/property-escapes/generated/Script_-_Anatolian_Hieroglyphs.js
+built-ins/RegExp/property-escapes/generated/Script_-_Arabic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Armenian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Avestan.js
+built-ins/RegExp/property-escapes/generated/Script_-_Balinese.js
+built-ins/RegExp/property-escapes/generated/Script_-_Bamum.js
+built-ins/RegExp/property-escapes/generated/Script_-_Bassa_Vah.js
+built-ins/RegExp/property-escapes/generated/Script_-_Batak.js
+built-ins/RegExp/property-escapes/generated/Script_-_Bengali.js
+built-ins/RegExp/property-escapes/generated/Script_-_Bhaiksuki.js
+built-ins/RegExp/property-escapes/generated/Script_-_Bopomofo.js
+built-ins/RegExp/property-escapes/generated/Script_-_Brahmi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Braille.js
+built-ins/RegExp/property-escapes/generated/Script_-_Buginese.js
+built-ins/RegExp/property-escapes/generated/Script_-_Buhid.js
+built-ins/RegExp/property-escapes/generated/Script_-_Canadian_Aboriginal.js
+built-ins/RegExp/property-escapes/generated/Script_-_Carian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Caucasian_Albanian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Chakma.js
+built-ins/RegExp/property-escapes/generated/Script_-_Cham.js
+built-ins/RegExp/property-escapes/generated/Script_-_Cherokee.js
+built-ins/RegExp/property-escapes/generated/Script_-_Chorasmian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Common.js
+built-ins/RegExp/property-escapes/generated/Script_-_Coptic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Cuneiform.js
+built-ins/RegExp/property-escapes/generated/Script_-_Cypriot.js
+built-ins/RegExp/property-escapes/generated/Script_-_Cyrillic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Deseret.js
+built-ins/RegExp/property-escapes/generated/Script_-_Devanagari.js
+built-ins/RegExp/property-escapes/generated/Script_-_Dives_Akuru.js
+built-ins/RegExp/property-escapes/generated/Script_-_Dogra.js
+built-ins/RegExp/property-escapes/generated/Script_-_Duployan.js
+built-ins/RegExp/property-escapes/generated/Script_-_Egyptian_Hieroglyphs.js
+built-ins/RegExp/property-escapes/generated/Script_-_Elbasan.js
+built-ins/RegExp/property-escapes/generated/Script_-_Elymaic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Ethiopic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Georgian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Glagolitic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Gothic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Grantha.js
+built-ins/RegExp/property-escapes/generated/Script_-_Greek.js
+built-ins/RegExp/property-escapes/generated/Script_-_Gujarati.js
+built-ins/RegExp/property-escapes/generated/Script_-_Gunjala_Gondi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Gurmukhi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Han.js
+built-ins/RegExp/property-escapes/generated/Script_-_Hangul.js
+built-ins/RegExp/property-escapes/generated/Script_-_Hanifi_Rohingya.js
+built-ins/RegExp/property-escapes/generated/Script_-_Hanunoo.js
+built-ins/RegExp/property-escapes/generated/Script_-_Hatran.js
+built-ins/RegExp/property-escapes/generated/Script_-_Hebrew.js
+built-ins/RegExp/property-escapes/generated/Script_-_Hiragana.js
+built-ins/RegExp/property-escapes/generated/Script_-_Imperial_Aramaic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Inherited.js
+built-ins/RegExp/property-escapes/generated/Script_-_Inscriptional_Pahlavi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Inscriptional_Parthian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Javanese.js
+built-ins/RegExp/property-escapes/generated/Script_-_Kaithi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Kannada.js
+built-ins/RegExp/property-escapes/generated/Script_-_Katakana.js
+built-ins/RegExp/property-escapes/generated/Script_-_Kayah_Li.js
+built-ins/RegExp/property-escapes/generated/Script_-_Kharoshthi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Khitan_Small_Script.js
+built-ins/RegExp/property-escapes/generated/Script_-_Khmer.js
+built-ins/RegExp/property-escapes/generated/Script_-_Khojki.js
+built-ins/RegExp/property-escapes/generated/Script_-_Khudawadi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Lao.js
+built-ins/RegExp/property-escapes/generated/Script_-_Latin.js
+built-ins/RegExp/property-escapes/generated/Script_-_Lepcha.js
+built-ins/RegExp/property-escapes/generated/Script_-_Limbu.js
+built-ins/RegExp/property-escapes/generated/Script_-_Linear_A.js
+built-ins/RegExp/property-escapes/generated/Script_-_Linear_B.js
+built-ins/RegExp/property-escapes/generated/Script_-_Lisu.js
+built-ins/RegExp/property-escapes/generated/Script_-_Lycian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Lydian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Mahajani.js
+built-ins/RegExp/property-escapes/generated/Script_-_Makasar.js
+built-ins/RegExp/property-escapes/generated/Script_-_Malayalam.js
+built-ins/RegExp/property-escapes/generated/Script_-_Mandaic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Manichaean.js
+built-ins/RegExp/property-escapes/generated/Script_-_Marchen.js
+built-ins/RegExp/property-escapes/generated/Script_-_Masaram_Gondi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Medefaidrin.js
+built-ins/RegExp/property-escapes/generated/Script_-_Meetei_Mayek.js
+built-ins/RegExp/property-escapes/generated/Script_-_Mende_Kikakui.js
+built-ins/RegExp/property-escapes/generated/Script_-_Meroitic_Cursive.js
+built-ins/RegExp/property-escapes/generated/Script_-_Meroitic_Hieroglyphs.js
+built-ins/RegExp/property-escapes/generated/Script_-_Miao.js
+built-ins/RegExp/property-escapes/generated/Script_-_Modi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Mongolian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Mro.js
+built-ins/RegExp/property-escapes/generated/Script_-_Multani.js
+built-ins/RegExp/property-escapes/generated/Script_-_Myanmar.js
+built-ins/RegExp/property-escapes/generated/Script_-_Nabataean.js
+built-ins/RegExp/property-escapes/generated/Script_-_Nandinagari.js
+built-ins/RegExp/property-escapes/generated/Script_-_New_Tai_Lue.js
+built-ins/RegExp/property-escapes/generated/Script_-_Newa.js
+built-ins/RegExp/property-escapes/generated/Script_-_Nko.js
+built-ins/RegExp/property-escapes/generated/Script_-_Nushu.js
+built-ins/RegExp/property-escapes/generated/Script_-_Nyiakeng_Puachue_Hmong.js
+built-ins/RegExp/property-escapes/generated/Script_-_Ogham.js
+built-ins/RegExp/property-escapes/generated/Script_-_Ol_Chiki.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_Hungarian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_Italic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_North_Arabian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_Permic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_Persian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_Sogdian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_South_Arabian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Old_Turkic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Oriya.js
+built-ins/RegExp/property-escapes/generated/Script_-_Osage.js
+built-ins/RegExp/property-escapes/generated/Script_-_Osmanya.js
+built-ins/RegExp/property-escapes/generated/Script_-_Pahawh_Hmong.js
+built-ins/RegExp/property-escapes/generated/Script_-_Palmyrene.js
+built-ins/RegExp/property-escapes/generated/Script_-_Pau_Cin_Hau.js
+built-ins/RegExp/property-escapes/generated/Script_-_Phags_Pa.js
+built-ins/RegExp/property-escapes/generated/Script_-_Phoenician.js
+built-ins/RegExp/property-escapes/generated/Script_-_Psalter_Pahlavi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Rejang.js
+built-ins/RegExp/property-escapes/generated/Script_-_Runic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Samaritan.js
+built-ins/RegExp/property-escapes/generated/Script_-_Saurashtra.js
+built-ins/RegExp/property-escapes/generated/Script_-_Sharada.js
+built-ins/RegExp/property-escapes/generated/Script_-_Shavian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Siddham.js
+built-ins/RegExp/property-escapes/generated/Script_-_SignWriting.js
+built-ins/RegExp/property-escapes/generated/Script_-_Sinhala.js
+built-ins/RegExp/property-escapes/generated/Script_-_Sogdian.js
+built-ins/RegExp/property-escapes/generated/Script_-_Sora_Sompeng.js
+built-ins/RegExp/property-escapes/generated/Script_-_Soyombo.js
+built-ins/RegExp/property-escapes/generated/Script_-_Sundanese.js
+built-ins/RegExp/property-escapes/generated/Script_-_Syloti_Nagri.js
+built-ins/RegExp/property-escapes/generated/Script_-_Syriac.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tagalog.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tagbanwa.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tai_Le.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tai_Tham.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tai_Viet.js
+built-ins/RegExp/property-escapes/generated/Script_-_Takri.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tamil.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tangut.js
+built-ins/RegExp/property-escapes/generated/Script_-_Telugu.js
+built-ins/RegExp/property-escapes/generated/Script_-_Thaana.js
+built-ins/RegExp/property-escapes/generated/Script_-_Thai.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tibetan.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tifinagh.js
+built-ins/RegExp/property-escapes/generated/Script_-_Tirhuta.js
+built-ins/RegExp/property-escapes/generated/Script_-_Ugaritic.js
+built-ins/RegExp/property-escapes/generated/Script_-_Vai.js
+built-ins/RegExp/property-escapes/generated/Script_-_Wancho.js
+built-ins/RegExp/property-escapes/generated/Script_-_Warang_Citi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Yezidi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Yi.js
+built-ins/RegExp/property-escapes/generated/Script_-_Zanabazar_Square.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Adlam.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ahom.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Anatolian_Hieroglyphs.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Arabic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Armenian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Avestan.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Balinese.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bamum.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bassa_Vah.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Batak.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bengali.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bhaiksuki.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Bopomofo.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Brahmi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Braille.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Buginese.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Buhid.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Canadian_Aboriginal.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Carian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Caucasian_Albanian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Chakma.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cham.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cherokee.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Chorasmian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Common.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Coptic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cuneiform.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cypriot.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Cyrillic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Deseret.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Devanagari.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Dives_Akuru.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Dogra.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Duployan.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Egyptian_Hieroglyphs.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Elbasan.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Elymaic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ethiopic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Georgian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Glagolitic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gothic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Grantha.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Greek.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gujarati.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gunjala_Gondi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Gurmukhi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Han.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hangul.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hanifi_Rohingya.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hanunoo.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hatran.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hebrew.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Hiragana.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Imperial_Aramaic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inherited.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inscriptional_Pahlavi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Inscriptional_Parthian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Javanese.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kaithi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kannada.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Katakana.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kayah_Li.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Kharoshthi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khitan_Small_Script.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khmer.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khojki.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Khudawadi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lao.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Latin.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lepcha.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Limbu.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Linear_A.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Linear_B.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lisu.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lycian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Lydian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mahajani.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Makasar.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Malayalam.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mandaic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Manichaean.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Marchen.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Masaram_Gondi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Medefaidrin.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Meetei_Mayek.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mende_Kikakui.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Meroitic_Cursive.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Meroitic_Hieroglyphs.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Miao.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Modi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mongolian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Mro.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Multani.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Myanmar.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nabataean.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nandinagari.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_New_Tai_Lue.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Newa.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nko.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nushu.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Nyiakeng_Puachue_Hmong.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ogham.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ol_Chiki.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Hungarian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Italic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_North_Arabian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Permic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Persian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Sogdian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_South_Arabian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Old_Turkic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Oriya.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Osage.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Osmanya.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Pahawh_Hmong.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Palmyrene.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Pau_Cin_Hau.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Phags_Pa.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Phoenician.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Psalter_Pahlavi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Rejang.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Runic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Samaritan.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Saurashtra.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sharada.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Shavian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Siddham.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_SignWriting.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sinhala.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sogdian.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sora_Sompeng.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Soyombo.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Sundanese.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Syloti_Nagri.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Syriac.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tagalog.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tagbanwa.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tai_Le.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tai_Tham.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tai_Viet.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Takri.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tamil.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tangut.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Telugu.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Thaana.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Thai.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tibetan.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tifinagh.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Tirhuta.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Ugaritic.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Vai.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Wancho.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Warang_Citi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Yezidi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Yi.js
+built-ins/RegExp/property-escapes/generated/Script_Extensions_-_Zanabazar_Square.js
+built-ins/RegExp/property-escapes/generated/Sentence_Terminal.js
+built-ins/RegExp/property-escapes/generated/Soft_Dotted.js
+built-ins/RegExp/property-escapes/generated/Terminal_Punctuation.js
+built-ins/RegExp/property-escapes/generated/Unified_Ideograph.js
+built-ins/RegExp/property-escapes/generated/Uppercase.js
+built-ins/RegExp/property-escapes/generated/Variation_Selector.js
+built-ins/RegExp/property-escapes/generated/White_Space.js
+built-ins/RegExp/property-escapes/generated/XID_Continue.js
+built-ins/RegExp/property-escapes/generated/XID_Start.js
+built-ins/String/prototype/indexOf/position-tointeger-bigint.js
+built-ins/String/prototype/indexOf/searchstring-tostring-bigint.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/coerced-values-end.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/coerced-values-start.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/coerced-values-target.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/negative-end.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/negative-out-of-bounds-end.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/negative-out-of-bounds-start.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/negative-out-of-bounds-target.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/negative-start.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/negative-target.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/non-negative-out-of-bounds-end.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/non-negative-out-of-bounds-target-and-start.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/non-negative-target-and-start.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/non-negative-target-start-and-end.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/return-this.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/undefined-end.js
+built-ins/TypedArray/prototype/entries/BigInt/iter-prototype.js
+built-ins/TypedArray/prototype/entries/BigInt/return-itor.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-arguments-with-thisarg.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-arguments-without-thisarg.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-no-interaction-over-non-integer.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-set-value-during-interaction.js
+built-ins/TypedArray/prototype/every/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/every/BigInt/values-are-not-cached.js
+built-ins/TypedArray/prototype/fill/BigInt/coerced-indexes.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values-conversion-once.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values-custom-start-and-end.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values-non-numeric-throw.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values-non-numeric.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values-relative-end.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values-relative-start.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values.js
+built-ins/TypedArray/prototype/fill/BigInt/get-length-ignores-length-prop.js
+built-ins/TypedArray/prototype/fill/BigInt/return-abrupt-from-end-as-symbol.js
+built-ins/TypedArray/prototype/fill/BigInt/return-abrupt-from-end.js
+built-ins/TypedArray/prototype/fill/BigInt/return-abrupt-from-set-value.js
+built-ins/TypedArray/prototype/fill/BigInt/return-abrupt-from-start-as-symbol.js
+built-ins/TypedArray/prototype/fill/BigInt/return-abrupt-from-start.js
+built-ins/TypedArray/prototype/fill/BigInt/return-this.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-arguments-with-thisarg.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-arguments-without-thisarg.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-no-iteration-over-non-integer.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-set-value-during-iteration.js
+built-ins/TypedArray/prototype/filter/BigInt/result-does-not-share-buffer.js
+built-ins/TypedArray/prototype/filter/BigInt/result-full-callbackfn-returns-true.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-ctor-abrupt.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-ctor-inherited.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-ctor-returns-throws.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-ctor.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-custom-ctor-invocation.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-custom-ctor-returns-another-instance.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-custom-ctor.js
+built-ins/TypedArray/prototype/filter/BigInt/values-are-not-cached.js
+built-ins/TypedArray/prototype/filter/BigInt/values-are-set.js
+built-ins/TypedArray/prototype/find/BigInt/get-length-ignores-length-prop.js
+built-ins/TypedArray/prototype/find/BigInt/predicate-call-changes-value.js
+built-ins/TypedArray/prototype/find/BigInt/predicate-call-parameters.js
+built-ins/TypedArray/prototype/find/BigInt/return-found-value-predicate-result-is-true.js
+built-ins/TypedArray/prototype/findIndex/BigInt/get-length-ignores-length-prop.js
+built-ins/TypedArray/prototype/findIndex/BigInt/predicate-call-changes-value.js
+built-ins/TypedArray/prototype/findIndex/BigInt/predicate-call-parameters.js
+built-ins/TypedArray/prototype/findIndex/BigInt/return-index-predicate-result-is-true.js
+built-ins/TypedArray/prototype/findIndex/BigInt/return-negative-one-if-predicate-returns-false-value.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-arguments-with-thisarg.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-arguments-without-thisarg.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-no-interaction-over-non-integer.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-set-value-during-interaction.js
+built-ins/TypedArray/prototype/forEach/BigInt/values-are-not-cached.js
+built-ins/TypedArray/prototype/includes/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/includes/BigInt/fromIndex-equal-or-greater-length-returns-false.js
+built-ins/TypedArray/prototype/includes/BigInt/fromIndex-infinity.js
+built-ins/TypedArray/prototype/includes/BigInt/fromIndex-minus-zero.js
+built-ins/TypedArray/prototype/includes/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/includes/BigInt/length-zero-returns-false.js
+built-ins/TypedArray/prototype/includes/BigInt/return-abrupt-tointeger-fromindex-symbol.js
+built-ins/TypedArray/prototype/includes/BigInt/return-abrupt-tointeger-fromindex.js
+built-ins/TypedArray/prototype/includes/BigInt/search-found-returns-true.js
+built-ins/TypedArray/prototype/includes/BigInt/search-not-found-returns-false.js
+built-ins/TypedArray/prototype/includes/BigInt/tointeger-fromindex.js
+built-ins/TypedArray/prototype/indexOf/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/indexOf/BigInt/fromIndex-equal-or-greater-length-returns-minus-one.js
+built-ins/TypedArray/prototype/indexOf/BigInt/fromIndex-infinity.js
+built-ins/TypedArray/prototype/indexOf/BigInt/fromIndex-minus-zero.js
+built-ins/TypedArray/prototype/indexOf/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/indexOf/BigInt/length-zero-returns-minus-one.js
+built-ins/TypedArray/prototype/indexOf/BigInt/no-arg.js
+built-ins/TypedArray/prototype/indexOf/BigInt/return-abrupt-tointeger-fromindex-symbol.js
+built-ins/TypedArray/prototype/indexOf/BigInt/return-abrupt-tointeger-fromindex.js
+built-ins/TypedArray/prototype/indexOf/BigInt/search-found-returns-index.js
+built-ins/TypedArray/prototype/indexOf/BigInt/search-not-found-returns-minus-one.js
+built-ins/TypedArray/prototype/indexOf/BigInt/tointeger-fromindex.js
+built-ins/TypedArray/prototype/join/BigInt/custom-separator-result-from-tostring-on-each-simple-value.js
+built-ins/TypedArray/prototype/join/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/join/BigInt/result-from-tostring-on-each-simple-value.js
+built-ins/TypedArray/prototype/keys/BigInt/iter-prototype.js
+built-ins/TypedArray/prototype/keys/BigInt/return-itor.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/fromIndex-infinity.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/fromIndex-minus-zero.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/length-zero-returns-minus-one.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/no-arg.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/return-abrupt-tointeger-fromindex-symbol.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/return-abrupt-tointeger-fromindex.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/search-found-returns-index.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/search-not-found-returns-minus-one.js
+built-ins/TypedArray/prototype/lastIndexOf/BigInt/tointeger-fromindex.js
+built-ins/TypedArray/prototype/map/BigInt/arraylength-internal.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-arguments-with-thisarg.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-arguments-without-thisarg.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-no-interaction-over-non-integer-properties.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-return-affects-returned-object.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-return-does-not-copy-non-integer-properties.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-set-value-during-interaction.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-this.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-ctor-abrupt.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-ctor-inherited.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-ctor-returns-throws.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-ctor.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-abrupt.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-custom-ctor-invocation.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-custom-ctor-length.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-custom-ctor-returns-another-instance.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-custom-ctor.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-use-default-ctor.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species.js
+built-ins/TypedArray/prototype/map/BigInt/values-are-not-cached.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-arguments-custom-accumulator.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-arguments-default-accumulator.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-no-iteration-over-non-integer-properties.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-set-value-during-iteration.js
+built-ins/TypedArray/prototype/reduce/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/reduce/BigInt/result-is-last-callbackfn-return.js
+built-ins/TypedArray/prototype/reduce/BigInt/result-of-any-type.js
+built-ins/TypedArray/prototype/reduce/BigInt/return-first-value-without-callbackfn.js
+built-ins/TypedArray/prototype/reduce/BigInt/values-are-not-cached.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-arguments-custom-accumulator.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-arguments-default-accumulator.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-no-iteration-over-non-integer-properties.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-set-value-during-iteration.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/result-is-last-callbackfn-return.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/result-of-any-type.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/return-first-value-without-callbackfn.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/values-are-not-cached.js
+built-ins/TypedArray/prototype/reverse/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/reverse/BigInt/reverts.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-negative-integer-offset-throws.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-offset-tointeger.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-primitive-toobject.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-src-get-length.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-src-get-value.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-src-length-symbol.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-src-length.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-src-tonumber-value-symbol.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-src-tonumber-value.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-tointeger-offset-symbol.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-toobject-offset.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-set-values-in-order.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-set-values.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-src-tonumber-value-type-conversions.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-src-values-are-not-cached.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-target-arraylength-internal.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-targetbuffer-detached-on-get-src-value-throws.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-targetbuffer-detached-on-tointeger-offset-throws.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-targetbuffer-detached-throws.js
+built-ins/TypedArray/prototype/set/BigInt/bigint-tobigint64.js
+built-ins/TypedArray/prototype/set/BigInt/bigint-tobiguint64.js
+built-ins/TypedArray/prototype/set/BigInt/boolean-tobigint.js
+built-ins/TypedArray/prototype/set/BigInt/src-typedarray-big.js
+built-ins/TypedArray/prototype/set/BigInt/string-tobigint.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-offset-tointeger.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-set-values-diff-buffer-other-type-sab.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-set-values-diff-buffer-other-type.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-set-values-diff-buffer-same-type-sab.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-set-values-diff-buffer-same-type.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-set-values-same-buffer-same-type-sab.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-set-values-same-buffer-same-type.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-src-arraylength-internal.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-src-byteoffset-internal.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-target-arraylength-internal.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-target-byteoffset-internal.js
+built-ins/TypedArray/prototype/set/src-typedarray-big-throws.js
+built-ins/TypedArray/prototype/slice/BigInt/arraylength-internal.js
+built-ins/TypedArray/prototype/slice/BigInt/infinity.js
+built-ins/TypedArray/prototype/slice/BigInt/minus-zero.js
+built-ins/TypedArray/prototype/slice/BigInt/result-does-not-copy-ordinary-properties.js
+built-ins/TypedArray/prototype/slice/BigInt/results-with-different-length.js
+built-ins/TypedArray/prototype/slice/BigInt/results-with-empty-length.js
+built-ins/TypedArray/prototype/slice/BigInt/results-with-same-length.js
+built-ins/TypedArray/prototype/slice/BigInt/set-values-from-different-ctor-type.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-ctor-abrupt.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-ctor-inherited.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-ctor-returns-throws.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-ctor.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-custom-ctor-invocation.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-custom-ctor-returns-another-instance.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-custom-ctor.js
+built-ins/TypedArray/prototype/slice/BigInt/tointeger-end.js
+built-ins/TypedArray/prototype/slice/BigInt/tointeger-start.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-arguments-with-thisarg.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-arguments-without-thisarg.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-no-interaction-over-non-integer.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-return-does-not-change-instance.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-set-value-during-interaction.js
+built-ins/TypedArray/prototype/some/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/some/BigInt/values-are-not-cached.js
+built-ins/TypedArray/prototype/sort/BigInt/arraylength-internal.js
+built-ins/TypedArray/prototype/sort/BigInt/comparefn-call-throws.js
+built-ins/TypedArray/prototype/sort/BigInt/comparefn-calls.js
+built-ins/TypedArray/prototype/sort/BigInt/comparefn-nonfunction-call-throws.js
+built-ins/TypedArray/prototype/sort/BigInt/return-same-instance.js
+built-ins/TypedArray/prototype/sort/BigInt/sortcompare-with-no-tostring.js
+built-ins/TypedArray/prototype/sort/BigInt/sorted-values.js
+built-ins/TypedArray/prototype/subarray/BigInt/infinity.js
+built-ins/TypedArray/prototype/subarray/BigInt/minus-zero.js
+built-ins/TypedArray/prototype/subarray/BigInt/result-does-not-copy-ordinary-properties.js
+built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-from-same-ctor.js
+built-ins/TypedArray/prototype/subarray/BigInt/result-is-new-instance-with-shared-buffer.js
+built-ins/TypedArray/prototype/subarray/BigInt/results-with-different-length.js
+built-ins/TypedArray/prototype/subarray/BigInt/results-with-empty-length.js
+built-ins/TypedArray/prototype/subarray/BigInt/results-with-same-length.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-abrupt.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-inherited.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor-returns-throws.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-ctor.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-invocation.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-returns-another-instance.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor.js
+built-ins/TypedArray/prototype/subarray/BigInt/tointeger-begin.js
+built-ins/TypedArray/prototype/subarray/BigInt/tointeger-end.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/calls-tolocalestring-from-each-value.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/calls-tostring-from-each-value.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/calls-valueof-from-each-value.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/return-abrupt-from-firstelement-tolocalestring.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/return-abrupt-from-firstelement-tostring.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/return-abrupt-from-firstelement-valueof.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/return-abrupt-from-nextelement-tolocalestring.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/return-abrupt-from-nextelement-tostring.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/return-abrupt-from-nextelement-valueof.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/return-result.js
+built-ins/TypedArray/prototype/values/BigInt/iter-prototype.js
+built-ins/TypedArray/prototype/values/BigInt/return-itor.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/init-zeros.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/as-array-returns.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/as-generator-iterable-returns.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/bigint-tobigint64.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/bigint-tobiguint64.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/boolean-tobigint.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/new-instance-extensibility.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/string-tobigint.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-from-property.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-setting-obj-to-primitive-typeerror.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-setting-obj-to-primitive.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-setting-obj-tostring.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-setting-obj-valueof-typeerror.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-setting-obj-valueof.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-setting-property.js
+built-ins/TypedArrayConstructors/from/BigInt/custom-ctor-returns-other-instance.js
+built-ins/TypedArrayConstructors/from/BigInt/custom-ctor-returns-smaller-instance-throws.js
+built-ins/TypedArrayConstructors/from/BigInt/mapfn-abrupt-completion.js
+built-ins/TypedArrayConstructors/from/BigInt/mapfn-arguments.js
+built-ins/TypedArrayConstructors/from/BigInt/mapfn-this-with-thisarg.js
+built-ins/TypedArrayConstructors/from/BigInt/mapfn-this-without-thisarg-strict.js
+built-ins/TypedArrayConstructors/from/BigInt/new-instance-from-ordinary-object.js
+built-ins/TypedArrayConstructors/from/BigInt/new-instance-from-sparse-array.js
+built-ins/TypedArrayConstructors/from/BigInt/new-instance-using-custom-ctor.js
+built-ins/TypedArrayConstructors/from/BigInt/new-instance-with-mapfn.js
+built-ins/TypedArrayConstructors/from/BigInt/new-instance-without-mapfn.js
+built-ins/TypedArrayConstructors/from/BigInt/set-value-abrupt-completion.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/desc-value-throws.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-greater-than-last-index.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-lower-than-zero.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-minus-zero.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-not-canonical-index.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-not-integer.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-numericindex-accessor-desc.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-numericindex-desc-configurable.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-numericindex-desc-not-enumerable.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-numericindex-desc-not-writable.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-numericindex.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/non-extensible-new-key.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/non-extensible-redefine-key.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/set-value.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/this-is-not-extensible.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/BigInt/tonumber-value-detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/detached-buffer-key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/indexed-value-sab.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/indexed-value.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/key-is-not-integer.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/key-is-not-minus-zero.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/key-is-out-of-bounds.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/detached-buffer-key-is-not-number.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/index-prop-desc.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/key-is-minus-zero.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/key-is-not-canonical-index.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/key-is-not-integer.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/key-is-out-of-bounds.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/detached-buffer-key-is-not-number.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/indexed-value.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/key-is-not-canonical-index.js
+built-ins/TypedArrayConstructors/internals/OwnPropertyKeys/BigInt/integer-indexes-and-string-and-symbol-keys-.js
+built-ins/TypedArrayConstructors/internals/OwnPropertyKeys/BigInt/integer-indexes-and-string-keys.js
+built-ins/TypedArrayConstructors/internals/OwnPropertyKeys/BigInt/integer-indexes.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/bigint-tobigint64.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/bigint-tobiguint64.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/boolean-tobigint.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/detached-buffer-key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/indexed-value.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/key-is-minus-zero.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/key-is-not-canonical-index.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/key-is-not-integer.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/key-is-out-of-bounds.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/string-tobigint.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/tonumber-value-detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/tonumber-value-throws.js
+built-ins/TypedArrayConstructors/internals/Set/bigint-tonumber.js
+built-ins/TypedArrayConstructors/of/BigInt/argument-number-value-throws.js
+built-ins/TypedArrayConstructors/of/BigInt/custom-ctor-does-not-instantiate-ta-throws.js
+built-ins/TypedArrayConstructors/of/BigInt/custom-ctor-returns-other-instance.js
+built-ins/TypedArrayConstructors/of/BigInt/custom-ctor-returns-smaller-instance-throws.js
+built-ins/TypedArrayConstructors/of/BigInt/custom-ctor.js
+built-ins/TypedArrayConstructors/of/BigInt/new-instance-using-custom-ctor.js
+built-ins/TypedArrayConstructors/of/BigInt/new-instance.js
+built-ins/TypedArrayConstructors/of/BigInt/this-is-not-constructor.js
+harness/deepEqual-primitives-bigint.js
+intl402/BigInt/prototype/toLocaleString/de-DE.js
+intl402/BigInt/prototype/toLocaleString/default-options-object-prototype.js
+intl402/BigInt/prototype/toLocaleString/en-US.js
+intl402/BigInt/prototype/toLocaleString/returns-same-results-as-NumberFormat.js
+intl402/BigInt/prototype/toLocaleString/taint-Intl-NumberFormat.js
+intl402/BigInt/prototype/toLocaleString/this-value-invalid.js
+intl402/BigInt/prototype/toLocaleString/throws-same-exceptions-as-NumberFormat.js
+language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-multiple.js
+language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-null.js
+language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-single-args.js
+language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-undefined.js
+language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-multiple.js
+language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-null.js
+language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-single-args.js
+language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-undefined.js
+language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-multiple.js
+language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-null.js
+language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-single-args.js
+language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-undefined.js
+language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-multiple.js
+language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-null.js
+language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-single-args.js
+language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-undefined.js
+language/arguments-object/cls-decl-private-meth-args-trailing-comma-multiple.js
+language/arguments-object/cls-decl-private-meth-args-trailing-comma-null.js
+language/arguments-object/cls-decl-private-meth-args-trailing-comma-single-args.js
+language/arguments-object/cls-decl-private-meth-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-decl-private-meth-args-trailing-comma-undefined.js
+language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-multiple.js
+language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-null.js
+language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-single-args.js
+language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-undefined.js
+language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-multiple.js
+language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-null.js
+language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-single-args.js
+language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-undefined.js
+language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-multiple.js
+language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-null.js
+language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-single-args.js
+language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-undefined.js
+language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-multiple.js
+language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-null.js
+language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-single-args.js
+language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-undefined.js
+language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-multiple.js
+language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-null.js
+language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-single-args.js
+language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-undefined.js
+language/arguments-object/cls-expr-private-meth-args-trailing-comma-multiple.js
+language/arguments-object/cls-expr-private-meth-args-trailing-comma-null.js
+language/arguments-object/cls-expr-private-meth-args-trailing-comma-single-args.js
+language/arguments-object/cls-expr-private-meth-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-expr-private-meth-args-trailing-comma-undefined.js
+language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-multiple.js
+language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-null.js
+language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-single-args.js
+language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-spread-operator.js
+language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-undefined.js
+language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement-else-statement.js
+language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement.js
+language/comments/hashbang/line-terminator-carriage-return.js
+language/comments/hashbang/line-terminator-line-separator.js
+language/comments/hashbang/line-terminator-paragraph-separator.js
+language/comments/hashbang/module.js
+language/comments/hashbang/not-empty.js
+language/comments/hashbang/use-strict.js
+language/expressions/addition/bigint-and-number.js
+language/expressions/addition/bigint-arithmetic.js
+language/expressions/addition/bigint-errors.js
+language/expressions/addition/bigint-toprimitive.js
+language/expressions/addition/bigint-wrapped-values.js
+language/expressions/addition/coerce-bigint-to-string.js
+language/expressions/arrow-function/dstr/syntax-error-ident-ref-private-escaped.js
+language/expressions/arrow-function/dstr/syntax-error-ident-ref-protected-escaped.js
+language/expressions/arrow-function/dstr/syntax-error-ident-ref-static-escaped.js
+language/expressions/assignment/dstr/array-elem-target-simple-strict.js
+language/expressions/assignment/dstr/obj-id-simple-strict.js
+language/expressions/assignment/dstr/syntax-error-ident-ref-private-escaped.js
+language/expressions/assignment/dstr/syntax-error-ident-ref-protected-escaped.js
+language/expressions/assignment/dstr/syntax-error-ident-ref-static-escaped.js
+language/expressions/async-arrow-function/escaped-async-line-terminator.js
+language/expressions/async-arrow-function/rest-params-trailing-comma-early-error.js
+language/expressions/await/await-BindingIdentifier-in-global.js
+language/expressions/await/await-BindingIdentifier-nested.js
+language/expressions/await/await-in-nested-function.js
+language/expressions/await/await-in-nested-generator.js
+language/expressions/bitwise-and/bigint-and-number.js
+language/expressions/bitwise-and/bigint-errors.js
+language/expressions/bitwise-and/bigint-non-primitive.js
+language/expressions/bitwise-and/bigint-toprimitive.js
+language/expressions/bitwise-and/bigint-wrapped-values.js
+language/expressions/bitwise-and/bigint.js
+language/expressions/bitwise-not/bigint-non-primitive.js
+language/expressions/bitwise-not/bigint.js
+language/expressions/bitwise-or/bigint-and-number.js
+language/expressions/bitwise-or/bigint-errors.js
+language/expressions/bitwise-or/bigint-non-primitive.js
+language/expressions/bitwise-or/bigint-toprimitive.js
+language/expressions/bitwise-or/bigint-wrapped-values.js
+language/expressions/bitwise-or/bigint.js
+language/expressions/bitwise-xor/bigint-and-number.js
+language/expressions/bitwise-xor/bigint-errors.js
+language/expressions/bitwise-xor/bigint-non-primitive.js
+language/expressions/bitwise-xor/bigint-toprimitive.js
+language/expressions/bitwise-xor/bigint-wrapped-values.js
+language/expressions/bitwise-xor/bigint.js
+language/expressions/class/dstr/async-private-gen-meth-ary-init-iter-close.js
+language/expressions/class/dstr/async-private-gen-meth-ary-init-iter-no-close.js
+language/expressions/class/dstr/async-private-gen-meth-ary-name-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-elision.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-id.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-init-iter-close.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-init-iter-no-close.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-name-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elision.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-id.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/async-private-gen-meth-dflt-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/async-private-gen-meth-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-init-iter-close.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-init-iter-no-close.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-name-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-elision.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-init-iter-close.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-init-iter-no-close.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-name-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elision.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-empty.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/async-private-gen-meth-static-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-gen-meth-ary-init-iter-close.js
+language/expressions/class/dstr/private-gen-meth-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-gen-meth-ary-name-iter-val.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-elision.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-init-iter-close.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-name-iter-val.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-elision.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-gen-meth-dflt-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-gen-meth-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-gen-meth-static-ary-init-iter-close.js
+language/expressions/class/dstr/private-gen-meth-static-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-gen-meth-static-ary-name-iter-val.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-elision.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-init-iter-close.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-name-iter-val.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elision.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-empty.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-gen-meth-static-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-meth-ary-init-iter-close.js
+language/expressions/class/dstr/private-meth-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-meth-ary-name-iter-val.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-meth-ary-ptrn-elision.js
+language/expressions/class/dstr/private-meth-ary-ptrn-empty.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-meth-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-meth-dflt-ary-init-iter-close.js
+language/expressions/class/dstr/private-meth-dflt-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-meth-dflt-ary-name-iter-val.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-elision.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-empty.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-empty.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-meth-dflt-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-meth-obj-ptrn-empty.js
+language/expressions/class/dstr/private-meth-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-meth-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-meth-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-meth-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-meth-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-meth-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-meth-static-ary-init-iter-close.js
+language/expressions/class/dstr/private-meth-static-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-meth-static-ary-name-iter-val.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-elision.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-empty.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-init-iter-close.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-init-iter-no-close.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-name-iter-val.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-id.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elision-exhausted.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-elision.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-empty.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-elem.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-elision.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-empty.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-rest.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-id-elision.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-id.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-obj-id.js
+language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-empty.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-meth-static-dflt-obj-ptrn-rest-val-obj.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-empty.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-arrow.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-class.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-cover.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-fn.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-gen.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-id-init-skipped.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-ary-init.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-ary-trailing-comma.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-ary.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-id-init-skipped.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-id-init.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-id-trailing-comma.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-id.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-obj-init.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-prop-obj.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-rest-getter.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-rest-skip-non-enumerable.js
+language/expressions/class/dstr/private-meth-static-obj-ptrn-rest-val-obj.js
+language/expressions/class/elements/after-same-line-gen-computed-names.js
+language/expressions/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/after-same-line-gen-private-field-usage.js
+language/expressions/class/elements/after-same-line-gen-private-method-getter-usage.js
+language/expressions/class/elements/after-same-line-gen-private-method-usage.js
+language/expressions/class/elements/after-same-line-gen-private-names.js
+language/expressions/class/elements/after-same-line-gen-rs-private-getter-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-private-getter.js
+language/expressions/class/elements/after-same-line-gen-rs-private-method-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-private-method.js
+language/expressions/class/elements/after-same-line-gen-rs-private-setter-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-private-setter.js
+language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier.js
+language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
+language/expressions/class/elements/after-same-line-gen-static-private-fields.js
+language/expressions/class/elements/after-same-line-gen-static-private-methods-with-fields.js
+language/expressions/class/elements/after-same-line-gen-static-private-methods.js
+language/expressions/class/elements/after-same-line-gen-string-literal-names.js
+language/expressions/class/elements/after-same-line-method-computed-names.js
+language/expressions/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/after-same-line-method-private-field-usage.js
+language/expressions/class/elements/after-same-line-method-private-method-getter-usage.js
+language/expressions/class/elements/after-same-line-method-private-method-usage.js
+language/expressions/class/elements/after-same-line-method-private-names.js
+language/expressions/class/elements/after-same-line-method-rs-private-getter-alt.js
+language/expressions/class/elements/after-same-line-method-rs-private-getter.js
+language/expressions/class/elements/after-same-line-method-rs-private-method-alt.js
+language/expressions/class/elements/after-same-line-method-rs-private-method.js
+language/expressions/class/elements/after-same-line-method-rs-private-setter-alt.js
+language/expressions/class/elements/after-same-line-method-rs-private-setter.js
+language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-method-rs-privatename-identifier.js
+language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier.js
+language/expressions/class/elements/after-same-line-method-static-private-fields.js
+language/expressions/class/elements/after-same-line-method-static-private-methods-with-fields.js
+language/expressions/class/elements/after-same-line-method-static-private-methods.js
+language/expressions/class/elements/after-same-line-method-string-literal-names.js
+language/expressions/class/elements/after-same-line-static-async-gen-computed-names.js
+language/expressions/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/after-same-line-static-async-gen-private-field-usage.js
+language/expressions/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
+language/expressions/class/elements/after-same-line-static-async-gen-private-method-usage.js
+language/expressions/class/elements/after-same-line-static-async-gen-private-names.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-gen-static-private-fields.js
+language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
+language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods.js
+language/expressions/class/elements/after-same-line-static-async-gen-string-literal-names.js
+language/expressions/class/elements/after-same-line-static-async-method-computed-names.js
+language/expressions/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/after-same-line-static-async-method-private-field-usage.js
+language/expressions/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
+language/expressions/class/elements/after-same-line-static-async-method-private-method-usage.js
+language/expressions/class/elements/after-same-line-static-async-method-private-names.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-private-method.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-async-method-static-private-fields.js
+language/expressions/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
+language/expressions/class/elements/after-same-line-static-async-method-static-private-methods.js
+language/expressions/class/elements/after-same-line-static-async-method-string-literal-names.js
+language/expressions/class/elements/after-same-line-static-gen-computed-names.js
+language/expressions/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/after-same-line-static-gen-private-field-usage.js
+language/expressions/class/elements/after-same-line-static-gen-private-method-getter-usage.js
+language/expressions/class/elements/after-same-line-static-gen-private-method-usage.js
+language/expressions/class/elements/after-same-line-static-gen-private-names.js
+language/expressions/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-private-getter.js
+language/expressions/class/elements/after-same-line-static-gen-rs-private-method-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-private-method.js
+language/expressions/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-private-setter.js
+language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-gen-static-private-fields.js
+language/expressions/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
+language/expressions/class/elements/after-same-line-static-gen-static-private-methods.js
+language/expressions/class/elements/after-same-line-static-gen-string-literal-names.js
+language/expressions/class/elements/after-same-line-static-method-computed-names.js
+language/expressions/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/after-same-line-static-method-private-field-usage.js
+language/expressions/class/elements/after-same-line-static-method-private-method-getter-usage.js
+language/expressions/class/elements/after-same-line-static-method-private-method-usage.js
+language/expressions/class/elements/after-same-line-static-method-private-names.js
+language/expressions/class/elements/after-same-line-static-method-rs-private-getter-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-private-getter.js
+language/expressions/class/elements/after-same-line-static-method-rs-private-method-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-private-method.js
+language/expressions/class/elements/after-same-line-static-method-rs-private-setter-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-private-setter.js
+language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
+language/expressions/class/elements/after-same-line-static-method-static-private-fields.js
+language/expressions/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
+language/expressions/class/elements/after-same-line-static-method-static-private-methods.js
+language/expressions/class/elements/after-same-line-static-method-string-literal-names.js
+language/expressions/class/elements/arrow-fnc-init-err-contains-arguments.js
+language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
+language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
+language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
+language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
+language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
+language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
+language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
+language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
+language/expressions/class/elements/async-gen-private-method-static/yield-spread-obj.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-async-next.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-async-return.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-async-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-next.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-return.js
+language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
+language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
+language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
+language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
+language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
+language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next.js
+language/expressions/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
+language/expressions/class/elements/async-gen-private-method/yield-spread-arr-single.js
+language/expressions/class/elements/async-gen-private-method/yield-spread-obj.js
+language/expressions/class/elements/async-gen-private-method/yield-star-async-next.js
+language/expressions/class/elements/async-gen-private-method/yield-star-async-return.js
+language/expressions/class/elements/async-gen-private-method/yield-star-async-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+language/expressions/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
+language/expressions/class/elements/async-gen-private-method/yield-star-sync-next.js
+language/expressions/class/elements/async-gen-private-method/yield-star-sync-return.js
+language/expressions/class/elements/async-gen-private-method/yield-star-sync-throw.js
+language/expressions/class/elements/class-name-static-initializer-default-export.js
+language/expressions/class/elements/comp-name-init-err-contains-arguments.js
+language/expressions/class/elements/equality-init-err-contains-arguments.js
+language/expressions/class/elements/field-declaration.js
+language/expressions/class/elements/fields-anonymous-function-length.js
+language/expressions/class/elements/fields-literal-name-propname-constructor.js
+language/expressions/class/elements/fields-literal-name-static-propname-constructor.js
+language/expressions/class/elements/fields-multiple-definitions-static-private-methods-proxy.js
+language/expressions/class/elements/fields-string-name-propname-constructor.js
+language/expressions/class/elements/fields-string-name-static-propname-constructor.js
+language/expressions/class/elements/fields-string-name-static-propname-prototype.js
+language/expressions/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
+language/expressions/class/elements/gen-private-method-static/yield-spread-arr-single.js
+language/expressions/class/elements/gen-private-method-static/yield-spread-obj.js
+language/expressions/class/elements/gen-private-method/yield-spread-arr-multiple.js
+language/expressions/class/elements/gen-private-method/yield-spread-arr-single.js
+language/expressions/class/elements/gen-private-method/yield-spread-obj.js
+language/expressions/class/elements/grammar-private-field-optional-chaining.js
+language/expressions/class/elements/init-value-incremental.js
+language/expressions/class/elements/intercalated-static-non-static-computed-fields.js
+language/expressions/class/elements/literal-name-init-err-contains-arguments.js
+language/expressions/class/elements/multiple-definitions-computed-names.js
+language/expressions/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/multiple-definitions-private-field-usage.js
+language/expressions/class/elements/multiple-definitions-private-method-getter-usage.js
+language/expressions/class/elements/multiple-definitions-private-method-usage.js
+language/expressions/class/elements/multiple-definitions-private-names.js
+language/expressions/class/elements/multiple-definitions-rs-private-getter-alt.js
+language/expressions/class/elements/multiple-definitions-rs-private-getter.js
+language/expressions/class/elements/multiple-definitions-rs-private-method-alt.js
+language/expressions/class/elements/multiple-definitions-rs-private-method.js
+language/expressions/class/elements/multiple-definitions-rs-private-setter-alt.js
+language/expressions/class/elements/multiple-definitions-rs-private-setter.js
+language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/multiple-definitions-rs-privatename-identifier.js
+language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier.js
+language/expressions/class/elements/multiple-definitions-static-private-fields.js
+language/expressions/class/elements/multiple-definitions-static-private-methods-with-fields.js
+language/expressions/class/elements/multiple-definitions-static-private-methods.js
+language/expressions/class/elements/multiple-definitions-string-literal-names.js
+language/expressions/class/elements/multiple-stacked-definitions-computed-names.js
+language/expressions/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/multiple-stacked-definitions-private-field-usage.js
+language/expressions/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
+language/expressions/class/elements/multiple-stacked-definitions-private-method-usage.js
+language/expressions/class/elements/multiple-stacked-definitions-private-names.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-private-method.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
+language/expressions/class/elements/multiple-stacked-definitions-static-private-fields.js
+language/expressions/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
+language/expressions/class/elements/multiple-stacked-definitions-static-private-methods.js
+language/expressions/class/elements/multiple-stacked-definitions-string-literal-names.js
+language/expressions/class/elements/new-no-sc-line-method-computed-names.js
+language/expressions/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/new-no-sc-line-method-private-field-usage.js
+language/expressions/class/elements/new-no-sc-line-method-private-method-getter-usage.js
+language/expressions/class/elements/new-no-sc-line-method-private-method-usage.js
+language/expressions/class/elements/new-no-sc-line-method-private-names.js
+language/expressions/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-private-getter.js
+language/expressions/class/elements/new-no-sc-line-method-rs-private-method-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-private-method.js
+language/expressions/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-private-setter.js
+language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
+language/expressions/class/elements/new-no-sc-line-method-static-private-fields.js
+language/expressions/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
+language/expressions/class/elements/new-no-sc-line-method-static-private-methods.js
+language/expressions/class/elements/new-no-sc-line-method-string-literal-names.js
+language/expressions/class/elements/new-sc-line-gen-computed-names.js
+language/expressions/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/new-sc-line-gen-private-field-usage.js
+language/expressions/class/elements/new-sc-line-gen-private-method-getter-usage.js
+language/expressions/class/elements/new-sc-line-gen-private-method-usage.js
+language/expressions/class/elements/new-sc-line-gen-private-names.js
+language/expressions/class/elements/new-sc-line-gen-rs-private-getter-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-private-getter.js
+language/expressions/class/elements/new-sc-line-gen-rs-private-method-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-private-method.js
+language/expressions/class/elements/new-sc-line-gen-rs-private-setter-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-private-setter.js
+language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-gen-static-private-fields.js
+language/expressions/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
+language/expressions/class/elements/new-sc-line-gen-static-private-methods.js
+language/expressions/class/elements/new-sc-line-gen-string-literal-names.js
+language/expressions/class/elements/new-sc-line-method-computed-names.js
+language/expressions/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/new-sc-line-method-private-field-usage.js
+language/expressions/class/elements/new-sc-line-method-private-method-getter-usage.js
+language/expressions/class/elements/new-sc-line-method-private-method-usage.js
+language/expressions/class/elements/new-sc-line-method-private-names.js
+language/expressions/class/elements/new-sc-line-method-rs-private-getter-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-private-getter.js
+language/expressions/class/elements/new-sc-line-method-rs-private-method-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-private-method.js
+language/expressions/class/elements/new-sc-line-method-rs-private-setter-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-private-setter.js
+language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
+language/expressions/class/elements/new-sc-line-method-static-private-fields.js
+language/expressions/class/elements/new-sc-line-method-static-private-methods-with-fields.js
+language/expressions/class/elements/new-sc-line-method-static-private-methods.js
+language/expressions/class/elements/new-sc-line-method-string-literal-names.js
+language/expressions/class/elements/private-accessor-name/inst-private-escape-sequence-ZWJ.js
+language/expressions/class/elements/private-accessor-name/inst-private-escape-sequence-ZWNJ.js
+language/expressions/class/elements/private-accessor-name/inst-private-escape-sequence-u2118.js
+language/expressions/class/elements/private-accessor-name/inst-private-escape-sequence-u6F.js
+language/expressions/class/elements/private-accessor-name/inst-private-name-ZWJ.js
+language/expressions/class/elements/private-accessor-name/inst-private-name-ZWNJ.js
+language/expressions/class/elements/private-accessor-name/inst-private-name-common.js
+language/expressions/class/elements/private-accessor-name/inst-private-name-dollar.js
+language/expressions/class/elements/private-accessor-name/inst-private-name-u2118.js
+language/expressions/class/elements/private-accessor-name/inst-private-name-underscore.js
+language/expressions/class/elements/private-accessor-name/static-private-escape-sequence-ZWJ.js
+language/expressions/class/elements/private-accessor-name/static-private-escape-sequence-ZWNJ.js
+language/expressions/class/elements/private-accessor-name/static-private-escape-sequence-u2118.js
+language/expressions/class/elements/private-accessor-name/static-private-escape-sequence-u6F.js
+language/expressions/class/elements/private-accessor-name/static-private-name-ZWJ.js
+language/expressions/class/elements/private-accessor-name/static-private-name-ZWNJ.js
+language/expressions/class/elements/private-accessor-name/static-private-name-common.js
+language/expressions/class/elements/private-accessor-name/static-private-name-dollar.js
+language/expressions/class/elements/private-accessor-name/static-private-name-u2118.js
+language/expressions/class/elements/private-accessor-name/static-private-name-underscore.js
+language/expressions/class/elements/private-async-generator-method-name.js
+language/expressions/class/elements/private-async-method-name.js
+language/expressions/class/elements/private-derived-cls-direct-eval-contains-superproperty-1.js
+language/expressions/class/elements/private-derived-cls-direct-eval-contains-superproperty-2.js
+language/expressions/class/elements/private-derived-cls-direct-eval-err-contains-supercall-1.js
+language/expressions/class/elements/private-derived-cls-direct-eval-err-contains-supercall-2.js
+language/expressions/class/elements/private-derived-cls-direct-eval-err-contains-supercall.js
+language/expressions/class/elements/private-derived-cls-indirect-eval-contains-superproperty-1.js
+language/expressions/class/elements/private-derived-cls-indirect-eval-contains-superproperty-2.js
+language/expressions/class/elements/private-derived-cls-indirect-eval-err-contains-supercall-1.js
+language/expressions/class/elements/private-derived-cls-indirect-eval-err-contains-supercall-2.js
+language/expressions/class/elements/private-derived-cls-indirect-eval-err-contains-supercall.js
+language/expressions/class/elements/private-direct-eval-err-contains-arguments.js
+language/expressions/class/elements/private-direct-eval-err-contains-newtarget.js
+language/expressions/class/elements/private-field-access-on-inner-arrow-function.js
+language/expressions/class/elements/private-field-access-on-inner-function.js
+language/expressions/class/elements/private-field-after-optional-chain.js
+language/expressions/class/elements/private-field-as-arrow-function.js
+language/expressions/class/elements/private-field-as-async-arrow-function.js
+language/expressions/class/elements/private-field-as-async-function.js
+language/expressions/class/elements/private-field-as-function.js
+language/expressions/class/elements/private-field-on-nested-class.js
+language/expressions/class/elements/private-fields-proxy-default-handler-throws.js
+language/expressions/class/elements/private-generator-method-name.js
+language/expressions/class/elements/private-getter-access-on-inner-arrow-function.js
+language/expressions/class/elements/private-getter-access-on-inner-function.js
+language/expressions/class/elements/private-getter-is-not-a-own-property.js
+language/expressions/class/elements/private-getter-on-nested-class.js
+language/expressions/class/elements/private-getter-shadowed-by-field-on-nested-class.js
+language/expressions/class/elements/private-getter-shadowed-by-getter-on-nested-class.js
+language/expressions/class/elements/private-getter-shadowed-by-method-on-nested-class.js
+language/expressions/class/elements/private-getter-shadowed-by-setter-on-nested-class.js
+language/expressions/class/elements/private-indirect-eval-err-contains-arguments.js
+language/expressions/class/elements/private-indirect-eval-err-contains-newtarget.js
+language/expressions/class/elements/private-method-access-on-inner-arrow-function.js
+language/expressions/class/elements/private-method-access-on-inner-function.js
+language/expressions/class/elements/private-method-comparison.js
+language/expressions/class/elements/private-method-get-and-call.js
+language/expressions/class/elements/private-method-is-not-a-own-property.js
+language/expressions/class/elements/private-method-length.js
+language/expressions/class/elements/private-method-on-nested-class.js
+language/expressions/class/elements/private-method-referenced-from-static-method.js
+language/expressions/class/elements/private-method-shadowed-by-field-on-nested-class.js
+language/expressions/class/elements/private-method-shadowed-by-getter-on-nested-class.js
+language/expressions/class/elements/private-method-shadowed-by-setter-on-nested-class.js
+language/expressions/class/elements/private-method-shadowed-on-nested-class.js
+language/expressions/class/elements/private-methods/prod-private-async-generator.js
+language/expressions/class/elements/private-methods/prod-private-async-method.js
+language/expressions/class/elements/private-methods/prod-private-generator.js
+language/expressions/class/elements/private-methods/prod-private-method-initialize-order.js
+language/expressions/class/elements/private-methods/prod-private-method.js
+language/expressions/class/elements/private-setter-access-on-inner-arrow-function.js
+language/expressions/class/elements/private-setter-access-on-inner-function.js
+language/expressions/class/elements/private-setter-is-not-a-own-property.js
+language/expressions/class/elements/private-setter-on-nested-class.js
+language/expressions/class/elements/private-setter-shadowed-by-field-on-nested-class.js
+language/expressions/class/elements/private-setter-shadowed-by-getter-on-nested-class.js
+language/expressions/class/elements/private-setter-shadowed-by-method-on-nested-class.js
+language/expressions/class/elements/private-setter-shadowed-by-setter-on-nested-class.js
+language/expressions/class/elements/private-static-async-generator-method-name.js
+language/expressions/class/elements/private-static-async-method-name.js
+language/expressions/class/elements/private-static-field-shadowed-by-field-on-nested-class.js
+language/expressions/class/elements/private-static-field-shadowed-by-getter-on-nested-class.js
+language/expressions/class/elements/private-static-field-shadowed-by-method-on-nested-class.js
+language/expressions/class/elements/private-static-field-shadowed-by-setter-on-nested-class.js
+language/expressions/class/elements/private-static-field-usage-inside-nested-class.js
+language/expressions/class/elements/private-static-generator-method-name.js
+language/expressions/class/elements/private-static-method-length.js
+language/expressions/class/elements/private-static-method-name.js
+language/expressions/class/elements/private-static-method-shadowed-by-field-on-nested-class.js
+language/expressions/class/elements/private-static-method-shadowed-by-getter-on-nested-class.js
+language/expressions/class/elements/private-static-method-shadowed-by-method-on-nested-class.js
+language/expressions/class/elements/private-static-method-shadowed-by-setter-on-nested-class.js
+language/expressions/class/elements/private-static-method-usage-inside-nested-class.js
+language/expressions/class/elements/prod-private-getter-before-super-return-in-constructor.js
+language/expressions/class/elements/prod-private-getter-before-super-return-in-field-initializer.js
+language/expressions/class/elements/prod-private-method-before-super-return-in-constructor.js
+language/expressions/class/elements/prod-private-method-before-super-return-in-field-initializer.js
+language/expressions/class/elements/prod-private-setter-before-super-return-in-constructor.js
+language/expressions/class/elements/prod-private-setter-before-super-return-in-field-initializer.js
+language/expressions/class/elements/redeclaration.js
+language/expressions/class/elements/regular-definitions-computed-names.js
+language/expressions/class/elements/regular-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/regular-definitions-private-field-usage.js
+language/expressions/class/elements/regular-definitions-private-method-getter-usage.js
+language/expressions/class/elements/regular-definitions-private-method-usage.js
+language/expressions/class/elements/regular-definitions-private-names.js
+language/expressions/class/elements/regular-definitions-rs-private-getter-alt.js
+language/expressions/class/elements/regular-definitions-rs-private-getter.js
+language/expressions/class/elements/regular-definitions-rs-private-method-alt.js
+language/expressions/class/elements/regular-definitions-rs-private-method.js
+language/expressions/class/elements/regular-definitions-rs-private-setter-alt.js
+language/expressions/class/elements/regular-definitions-rs-private-setter.js
+language/expressions/class/elements/regular-definitions-rs-privatename-identifier-alt.js
+language/expressions/class/elements/regular-definitions-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/regular-definitions-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/regular-definitions-rs-privatename-identifier.js
+language/expressions/class/elements/regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/regular-definitions-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/regular-definitions-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/regular-definitions-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/regular-definitions-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/regular-definitions-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/regular-definitions-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/regular-definitions-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/regular-definitions-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/regular-definitions-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/regular-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/regular-definitions-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/regular-definitions-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/regular-definitions-rs-static-privatename-identifier.js
+language/expressions/class/elements/regular-definitions-static-private-fields.js
+language/expressions/class/elements/regular-definitions-static-private-methods-with-fields.js
+language/expressions/class/elements/regular-definitions-static-private-methods.js
+language/expressions/class/elements/regular-definitions-string-literal-names.js
+language/expressions/class/elements/same-line-async-gen-computed-names.js
+language/expressions/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/same-line-async-gen-private-field-usage.js
+language/expressions/class/elements/same-line-async-gen-private-method-getter-usage.js
+language/expressions/class/elements/same-line-async-gen-private-method-usage.js
+language/expressions/class/elements/same-line-async-gen-private-names.js
+language/expressions/class/elements/same-line-async-gen-rs-private-getter-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-private-getter.js
+language/expressions/class/elements/same-line-async-gen-rs-private-method-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-private-method.js
+language/expressions/class/elements/same-line-async-gen-rs-private-setter-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-private-setter.js
+language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier.js
+language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
+language/expressions/class/elements/same-line-async-gen-static-private-fields.js
+language/expressions/class/elements/same-line-async-gen-static-private-methods-with-fields.js
+language/expressions/class/elements/same-line-async-gen-static-private-methods.js
+language/expressions/class/elements/same-line-async-gen-string-literal-names.js
+language/expressions/class/elements/same-line-async-method-computed-names.js
+language/expressions/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/same-line-async-method-private-field-usage.js
+language/expressions/class/elements/same-line-async-method-private-method-getter-usage.js
+language/expressions/class/elements/same-line-async-method-private-method-usage.js
+language/expressions/class/elements/same-line-async-method-private-names.js
+language/expressions/class/elements/same-line-async-method-rs-private-getter-alt.js
+language/expressions/class/elements/same-line-async-method-rs-private-getter.js
+language/expressions/class/elements/same-line-async-method-rs-private-method-alt.js
+language/expressions/class/elements/same-line-async-method-rs-private-method.js
+language/expressions/class/elements/same-line-async-method-rs-private-setter-alt.js
+language/expressions/class/elements/same-line-async-method-rs-private-setter.js
+language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-async-method-rs-privatename-identifier.js
+language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier.js
+language/expressions/class/elements/same-line-async-method-static-private-fields.js
+language/expressions/class/elements/same-line-async-method-static-private-methods-with-fields.js
+language/expressions/class/elements/same-line-async-method-static-private-methods.js
+language/expressions/class/elements/same-line-async-method-string-literal-names.js
+language/expressions/class/elements/same-line-gen-computed-names.js
+language/expressions/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/same-line-gen-private-field-usage.js
+language/expressions/class/elements/same-line-gen-private-method-getter-usage.js
+language/expressions/class/elements/same-line-gen-private-method-usage.js
+language/expressions/class/elements/same-line-gen-private-names.js
+language/expressions/class/elements/same-line-gen-rs-private-getter-alt.js
+language/expressions/class/elements/same-line-gen-rs-private-getter.js
+language/expressions/class/elements/same-line-gen-rs-private-method-alt.js
+language/expressions/class/elements/same-line-gen-rs-private-method.js
+language/expressions/class/elements/same-line-gen-rs-private-setter-alt.js
+language/expressions/class/elements/same-line-gen-rs-private-setter.js
+language/expressions/class/elements/same-line-gen-rs-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-gen-rs-privatename-identifier.js
+language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier.js
+language/expressions/class/elements/same-line-gen-static-private-fields.js
+language/expressions/class/elements/same-line-gen-static-private-methods-with-fields.js
+language/expressions/class/elements/same-line-gen-static-private-methods.js
+language/expressions/class/elements/same-line-gen-string-literal-names.js
+language/expressions/class/elements/same-line-method-computed-names.js
+language/expressions/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/same-line-method-private-field-usage.js
+language/expressions/class/elements/same-line-method-private-method-getter-usage.js
+language/expressions/class/elements/same-line-method-private-method-usage.js
+language/expressions/class/elements/same-line-method-private-names.js
+language/expressions/class/elements/same-line-method-rs-private-getter-alt.js
+language/expressions/class/elements/same-line-method-rs-private-getter.js
+language/expressions/class/elements/same-line-method-rs-private-method-alt.js
+language/expressions/class/elements/same-line-method-rs-private-method.js
+language/expressions/class/elements/same-line-method-rs-private-setter-alt.js
+language/expressions/class/elements/same-line-method-rs-private-setter.js
+language/expressions/class/elements/same-line-method-rs-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-method-rs-privatename-identifier.js
+language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/same-line-method-rs-static-privatename-identifier.js
+language/expressions/class/elements/same-line-method-static-private-fields.js
+language/expressions/class/elements/same-line-method-static-private-methods-with-fields.js
+language/expressions/class/elements/same-line-method-static-private-methods.js
+language/expressions/class/elements/same-line-method-string-literal-names.js
+language/expressions/class/elements/static-as-valid-instance-field-assigned.js
+language/expressions/class/elements/static-as-valid-instance-field.js
+language/expressions/class/elements/static-as-valid-static-field-assigned.js
+language/expressions/class/elements/static-as-valid-static-field.js
+language/expressions/class/elements/static-comp-name-init-err-contains-arguments.js
+language/expressions/class/elements/static-field-anonymous-function-length.js
+language/expressions/class/elements/static-field-anonymous-function-name.js
+language/expressions/class/elements/static-field-declaration.js
+language/expressions/class/elements/static-literal-init-err-contains-arguments.js
+language/expressions/class/elements/static-private-fields-proxy-default-handler-throws.js
+language/expressions/class/elements/static-private-getter-access-on-inner-arrow-function.js
+language/expressions/class/elements/static-private-getter-access-on-inner-class.js
+language/expressions/class/elements/static-private-getter-access-on-inner-function.js
+language/expressions/class/elements/static-private-getter.js
+language/expressions/class/elements/static-private-method-access-on-inner-arrow-function.js
+language/expressions/class/elements/static-private-method-access-on-inner-function.js
+language/expressions/class/elements/static-private-method-and-instance-method-brand-check.js
+language/expressions/class/elements/static-private-method-referenced-from-instance-method.js
+language/expressions/class/elements/static-private-method-subclass-receiver.js
+language/expressions/class/elements/static-private-methods-proxy-default-handler-throws.js
+language/expressions/class/elements/static-private-setter-access-on-inner-arrow-function.js
+language/expressions/class/elements/static-private-setter-access-on-inner-class.js
+language/expressions/class/elements/static-private-setter-access-on-inner-function.js
+language/expressions/class/elements/static-private-setter.js
+language/expressions/class/elements/static-string-literal-name-init-err-contains-arguments.js
+language/expressions/class/elements/string-literal-name-init-err-contains-arguments.js
+language/expressions/class/elements/syntax/valid/grammar-privatemeth-duplicate-get-set.js
+language/expressions/class/elements/syntax/valid/grammar-privatemeth-duplicate-meth-nestedclassmeth.js
+language/expressions/class/elements/syntax/valid/grammar-privatename-classelementname-initializer-alt.js
+language/expressions/class/elements/syntax/valid/grammar-privatename-classelementname-initializer.js
+language/expressions/class/elements/syntax/valid/grammar-privatename-identifier.js
+language/expressions/class/elements/syntax/valid/grammar-privatename-no-initializer-with-method.js
+language/expressions/class/elements/syntax/valid/grammar-privatenames-multi-line.js
+language/expressions/class/elements/syntax/valid/grammar-static-private-async-gen-meth-prototype.js
+language/expressions/class/elements/syntax/valid/grammar-static-private-async-meth-prototype.js
+language/expressions/class/elements/syntax/valid/grammar-static-private-gen-meth-prototype.js
+language/expressions/class/elements/syntax/valid/grammar-static-private-meth-prototype.js
+language/expressions/class/elements/ternary-init-err-contains-arguments.js
+language/expressions/class/elements/typeof-init-err-contains-arguments.js
+language/expressions/class/elements/wrapped-in-sc-computed-names.js
+language/expressions/class/elements/wrapped-in-sc-grammar-privatename-identifier-semantics-stringvalue.js
+language/expressions/class/elements/wrapped-in-sc-private-field-usage.js
+language/expressions/class/elements/wrapped-in-sc-private-method-getter-usage.js
+language/expressions/class/elements/wrapped-in-sc-private-method-usage.js
+language/expressions/class/elements/wrapped-in-sc-private-names.js
+language/expressions/class/elements/wrapped-in-sc-rs-private-getter-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-private-getter.js
+language/expressions/class/elements/wrapped-in-sc-rs-private-method-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-private-method.js
+language/expressions/class/elements/wrapped-in-sc-rs-private-setter-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-private-setter.js
+language/expressions/class/elements/wrapped-in-sc-rs-privatename-identifier-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-privatename-identifier-initializer.js
+language/expressions/class/elements/wrapped-in-sc-rs-privatename-identifier.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-async-method-privatename-identifier-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-async-method-privatename-identifier.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-method-privatename-identifier-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-method-privatename-identifier.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-privatename-identifier-alt-by-classname.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-privatename-identifier-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-privatename-identifier-by-classname.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-privatename-identifier-initializer-alt.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-privatename-identifier-initializer.js
+language/expressions/class/elements/wrapped-in-sc-rs-static-privatename-identifier.js
+language/expressions/class/elements/wrapped-in-sc-static-private-fields.js
+language/expressions/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
+language/expressions/class/elements/wrapped-in-sc-static-private-methods.js
+language/expressions/class/elements/wrapped-in-sc-string-literal-names.js
+language/expressions/class/private-getter-brand-check-multiple-evaluations-of-class-factory.js
+language/expressions/class/private-method-brand-check-multiple-evaluations-of-class-factory.js
+language/expressions/class/private-setter-brand-check-multiple-evaluations-of-class-factory.js
+language/expressions/class/private-static-field-multiple-evaluations-of-class-factory.js
+language/expressions/class/private-static-getter-multiple-evaluations-of-class-factory.js
+language/expressions/class/private-static-method-brand-check-multiple-evaluations-of-class-factory.js
+language/expressions/class/private-static-setter-multiple-evaluations-of-class-factory.js
+language/expressions/coalesce/abrupt-is-a-short-circuit.js
+language/expressions/coalesce/chainable-if-parenthesis-covered-logical-and.js
+language/expressions/coalesce/chainable-if-parenthesis-covered-logical-or.js
+language/expressions/coalesce/chainable-with-bitwise-and.js
+language/expressions/coalesce/chainable-with-bitwise-or.js
+language/expressions/coalesce/chainable-with-bitwise-xor.js
+language/expressions/coalesce/chainable.js
+language/expressions/coalesce/follows-null.js
+language/expressions/coalesce/follows-undefined.js
+language/expressions/coalesce/short-circuit-number-0.js
+language/expressions/coalesce/short-circuit-number-42.js
+language/expressions/coalesce/short-circuit-number-empty-string.js
+language/expressions/coalesce/short-circuit-number-false.js
+language/expressions/coalesce/short-circuit-number-object.js
+language/expressions/coalesce/short-circuit-number-string.js
+language/expressions/coalesce/short-circuit-number-symbol.js
+language/expressions/coalesce/short-circuit-number-true.js
+language/expressions/coalesce/short-circuit-prevents-evaluation.js
+language/expressions/coalesce/tco-pos-null.js
+language/expressions/coalesce/tco-pos-undefined.js
+language/expressions/conditional/coalesce-expr-ternary.js
+language/expressions/division/bigint-and-number.js
+language/expressions/division/bigint-arithmetic.js
+language/expressions/division/bigint-complex-infinity.js
+language/expressions/division/bigint-errors.js
+language/expressions/division/bigint-toprimitive.js
+language/expressions/division/bigint-wrapped-values.js
+language/expressions/does-not-equals/bigint-and-bigint.js
+language/expressions/does-not-equals/bigint-and-boolean.js
+language/expressions/does-not-equals/bigint-and-incomparable-primitive.js
+language/expressions/does-not-equals/bigint-and-non-finite.js
+language/expressions/does-not-equals/bigint-and-number-extremes.js
+language/expressions/does-not-equals/bigint-and-number.js
+language/expressions/does-not-equals/bigint-and-object.js
+language/expressions/does-not-equals/bigint-and-string.js
+language/expressions/dynamic-import/always-create-new-promise.js
+language/expressions/dynamic-import/assign-expr-get-value-abrupt-throws.js
+language/expressions/dynamic-import/assignment-expression/additive-expr.js
+language/expressions/dynamic-import/assignment-expression/array-literal.js
+language/expressions/dynamic-import/assignment-expression/arrow-function.js
+language/expressions/dynamic-import/assignment-expression/await-expr.js
+language/expressions/dynamic-import/assignment-expression/await-identifier.js
+language/expressions/dynamic-import/assignment-expression/call-expr-arguments.js
+language/expressions/dynamic-import/assignment-expression/call-expr-expr.js
+language/expressions/dynamic-import/assignment-expression/call-expr-identifier.js
+language/expressions/dynamic-import/assignment-expression/cover-call-expr.js
+language/expressions/dynamic-import/assignment-expression/cover-parenthesized-expr.js
+language/expressions/dynamic-import/assignment-expression/identifier.js
+language/expressions/dynamic-import/assignment-expression/import-meta.js
+language/expressions/dynamic-import/assignment-expression/lhs-assign-operator-assign-expr.js
+language/expressions/dynamic-import/assignment-expression/lhs-eq-assign-expr.js
+language/expressions/dynamic-import/assignment-expression/logical-and-expr.js
+language/expressions/dynamic-import/assignment-expression/logical-or-expr.js
+language/expressions/dynamic-import/assignment-expression/member-expr.js
+language/expressions/dynamic-import/assignment-expression/new-target.js
+language/expressions/dynamic-import/assignment-expression/object-literal.js
+language/expressions/dynamic-import/assignment-expression/tagged-function-call.js
+language/expressions/dynamic-import/assignment-expression/ternary.js
+language/expressions/dynamic-import/assignment-expression/this.js
+language/expressions/dynamic-import/assignment-expression/unary-expr.js
+language/expressions/dynamic-import/assignment-expression/yield-assign-expr.js
+language/expressions/dynamic-import/assignment-expression/yield-expr.js
+language/expressions/dynamic-import/assignment-expression/yield-star.js
+language/expressions/dynamic-import/await-import-evaluation.js
+language/expressions/dynamic-import/catch/nested-arrow-import-catch-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-arrow-import-catch-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-arrow-import-catch-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-arrow-import-catch-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-arrow-import-catch-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-arrow-import-catch-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-arrow-import-catch-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-await-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-await-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-await-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-await-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-await-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-await-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-await-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-return-await-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-return-await-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-return-await-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-return-await-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-return-await-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-return-await-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-async-arrow-function-return-await-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-async-function-await-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-async-function-await-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-async-function-await-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-async-function-await-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-async-function-await-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-async-function-await-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-async-function-await-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-async-function-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-async-function-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-async-function-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-async-function-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-async-function-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-async-function-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-async-function-return-await-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-async-function-return-await-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-async-function-return-await-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-async-function-return-await-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-async-function-return-await-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-async-function-return-await-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-async-function-return-await-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-async-function-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-async-gen-await-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-async-gen-await-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-async-gen-await-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-async-gen-await-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-async-gen-await-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-async-gen-await-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-async-gen-await-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-async-gen-return-await-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-async-gen-return-await-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-async-gen-return-await-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-async-gen-return-await-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-async-gen-return-await-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-async-gen-return-await-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-async-gen-return-await-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-block-import-catch-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-block-import-catch-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-block-import-catch-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-block-import-catch-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-block-import-catch-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-block-import-catch-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-block-import-catch-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-block-labeled-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-block-labeled-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-block-labeled-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-block-labeled-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-block-labeled-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-block-labeled-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-block-labeled-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-do-while-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-do-while-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-do-while-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-do-while-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-do-while-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-do-while-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-do-while-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-else-import-catch-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-else-import-catch-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-else-import-catch-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-else-import-catch-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-else-import-catch-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-else-import-catch-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-else-import-catch-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-function-import-catch-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-function-import-catch-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-function-import-catch-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-function-import-catch-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-function-import-catch-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-function-import-catch-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-function-import-catch-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-if-import-catch-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-if-import-catch-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-if-import-catch-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-if-import-catch-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-if-import-catch-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-if-import-catch-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-if-import-catch-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/nested-while-import-catch-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/nested-while-import-catch-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/nested-while-import-catch-eval-script-code-target.js
+language/expressions/dynamic-import/catch/nested-while-import-catch-file-does-not-exist.js
+language/expressions/dynamic-import/catch/nested-while-import-catch-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/nested-while-import-catch-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/nested-while-import-catch-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/catch/top-level-import-catch-eval-rqstd-abrupt-typeerror.js
+language/expressions/dynamic-import/catch/top-level-import-catch-eval-rqstd-abrupt-urierror.js
+language/expressions/dynamic-import/catch/top-level-import-catch-eval-script-code-target.js
+language/expressions/dynamic-import/catch/top-level-import-catch-file-does-not-exist.js
+language/expressions/dynamic-import/catch/top-level-import-catch-instn-iee-err-ambiguous-import.js
+language/expressions/dynamic-import/catch/top-level-import-catch-instn-iee-err-circular.js
+language/expressions/dynamic-import/catch/top-level-import-catch-specifier-tostring-abrupt-rejects.js
+language/expressions/dynamic-import/custom-primitive.js
+language/expressions/dynamic-import/eval-export-dflt-cls-anon.js
+language/expressions/dynamic-import/eval-export-dflt-cls-name-meth.js
+language/expressions/dynamic-import/eval-export-dflt-cls-named.js
+language/expressions/dynamic-import/eval-export-dflt-expr-cls-anon.js
+language/expressions/dynamic-import/eval-export-dflt-expr-cls-name-meth.js
+language/expressions/dynamic-import/eval-export-dflt-expr-cls-named.js
+language/expressions/dynamic-import/eval-export-dflt-expr-fn-anon.js
+language/expressions/dynamic-import/eval-export-dflt-expr-fn-named.js
+language/expressions/dynamic-import/eval-export-dflt-expr-gen-anon.js
+language/expressions/dynamic-import/eval-export-dflt-expr-gen-named.js
+language/expressions/dynamic-import/eval-export-dflt-expr-in.js
+language/expressions/dynamic-import/eval-rqstd-once.js
+language/expressions/dynamic-import/eval-self-once-module.js
+language/expressions/dynamic-import/eval-self-once-script.js
+language/expressions/dynamic-import/for-await-resolution-and-error-agen-yield.js
+language/expressions/dynamic-import/for-await-resolution-and-error-agen.js
+language/expressions/dynamic-import/for-await-resolution-and-error.js
+language/expressions/dynamic-import/imported-self-update.js
+language/expressions/dynamic-import/indirect-resolution.js
+language/expressions/dynamic-import/namespace/await-ns-Symbol-toStringTag.js
+language/expressions/dynamic-import/namespace/await-ns-define-own-property.js
+language/expressions/dynamic-import/namespace/await-ns-delete-exported-init-strict.js
+language/expressions/dynamic-import/namespace/await-ns-delete-non-exported-strict.js
+language/expressions/dynamic-import/namespace/await-ns-extensible.js
+language/expressions/dynamic-import/namespace/await-ns-get-nested-namespace-dflt-direct.js
+language/expressions/dynamic-import/namespace/await-ns-get-nested-namespace-dflt-indirect.js
+language/expressions/dynamic-import/namespace/await-ns-get-nested-namespace-props-nrml.js
+language/expressions/dynamic-import/namespace/await-ns-get-own-property-str-found-init.js
+language/expressions/dynamic-import/namespace/await-ns-get-own-property-str-not-found.js
+language/expressions/dynamic-import/namespace/await-ns-get-own-property-sym.js
+language/expressions/dynamic-import/namespace/await-ns-get-str-found.js
+language/expressions/dynamic-import/namespace/await-ns-get-str-not-found.js
+language/expressions/dynamic-import/namespace/await-ns-get-sym-found.js
+language/expressions/dynamic-import/namespace/await-ns-get-sym-not-found.js
+language/expressions/dynamic-import/namespace/await-ns-has-property-str-found-init.js
+language/expressions/dynamic-import/namespace/await-ns-has-property-str-not-found.js
+language/expressions/dynamic-import/namespace/await-ns-has-property-sym-found.js
+language/expressions/dynamic-import/namespace/await-ns-has-property-sym-not-found.js
+language/expressions/dynamic-import/namespace/await-ns-no-iterator.js
+language/expressions/dynamic-import/namespace/await-ns-own-property-keys-sort.js
+language/expressions/dynamic-import/namespace/await-ns-prevent-extensions-object.js
+language/expressions/dynamic-import/namespace/await-ns-prevent-extensions-reflect.js
+language/expressions/dynamic-import/namespace/await-ns-prop-descs.js
+language/expressions/dynamic-import/namespace/await-ns-prototype.js
+language/expressions/dynamic-import/namespace/await-ns-set-prototype-of-null.js
+language/expressions/dynamic-import/namespace/await-ns-set-prototype-of.js
+language/expressions/dynamic-import/namespace/await-ns-set-same-values-strict.js
+language/expressions/dynamic-import/namespace/await-ns-set-strict.js
+language/expressions/dynamic-import/namespace/default-property-not-set-own.js
+language/expressions/dynamic-import/namespace/promise-then-ns-Symbol-toStringTag.js
+language/expressions/dynamic-import/namespace/promise-then-ns-define-own-property.js
+language/expressions/dynamic-import/namespace/promise-then-ns-delete-exported-init-strict.js
+language/expressions/dynamic-import/namespace/promise-then-ns-delete-non-exported-strict.js
+language/expressions/dynamic-import/namespace/promise-then-ns-extensible.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-nested-namespace-dflt-direct.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-nested-namespace-dflt-indirect.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-nested-namespace-props-nrml.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-own-property-str-found-init.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-own-property-str-not-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-own-property-sym.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-str-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-str-not-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-sym-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-get-sym-not-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-has-property-str-found-init.js
+language/expressions/dynamic-import/namespace/promise-then-ns-has-property-str-not-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-has-property-sym-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-has-property-sym-not-found.js
+language/expressions/dynamic-import/namespace/promise-then-ns-no-iterator.js
+language/expressions/dynamic-import/namespace/promise-then-ns-own-property-keys-sort.js
+language/expressions/dynamic-import/namespace/promise-then-ns-prevent-extensions-object.js
+language/expressions/dynamic-import/namespace/promise-then-ns-prevent-extensions-reflect.js
+language/expressions/dynamic-import/namespace/promise-then-ns-prop-descs.js
+language/expressions/dynamic-import/namespace/promise-then-ns-prototype.js
+language/expressions/dynamic-import/namespace/promise-then-ns-set-prototype-of-null.js
+language/expressions/dynamic-import/namespace/promise-then-ns-set-prototype-of.js
+language/expressions/dynamic-import/namespace/promise-then-ns-set-same-values-strict.js
+language/expressions/dynamic-import/namespace/promise-then-ns-set-strict.js
+language/expressions/dynamic-import/returns-promise.js
+language/expressions/dynamic-import/reuse-namespace-object-from-import.js
+language/expressions/dynamic-import/reuse-namespace-object-from-script.js
+language/expressions/dynamic-import/reuse-namespace-object.js
+language/expressions/dynamic-import/syntax/valid/callexpression-arguments.js
+language/expressions/dynamic-import/syntax/valid/callexpression-templateliteral.js
+language/expressions/dynamic-import/syntax/valid/nested-arrow-assignment-expression-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-arrow-assignment-expression-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-arrow-assignment-expression-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-arrow-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-arrow-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-arrow-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-async-arrow-function-await-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-async-arrow-function-await-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-async-arrow-function-await-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-async-arrow-function-return-await-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-async-arrow-function-return-await-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-async-arrow-function-return-await-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-await-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-await-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-await-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-return-await-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-return-await-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-return-await-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-async-function-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-async-gen-await-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-async-gen-await-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-async-gen-await-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-block-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-block-labeled-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-block-labeled-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-block-labeled-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-block-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-block-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-do-while-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-do-while-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-do-while-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-else-braceless-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-else-braceless-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-else-braceless-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-else-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-else-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-else-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-function-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-function-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-function-return-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-function-return-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-function-return-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-function-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-if-braceless-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-if-braceless-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-if-braceless-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-if-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-if-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-if-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/nested-while-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/nested-while-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/nested-while-script-code-valid.js
+language/expressions/dynamic-import/syntax/valid/new-covered-expression-is-valid.js
+language/expressions/dynamic-import/syntax/valid/top-level-empty-str-is-valid-assign-expr.js
+language/expressions/dynamic-import/syntax/valid/top-level-nested-imports.js
+language/expressions/dynamic-import/syntax/valid/top-level-script-code-valid.js
+language/expressions/dynamic-import/update-to-dynamic-import.js
+language/expressions/dynamic-import/usage/nested-arrow-assignment-expression-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-arrow-assignment-expression-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-arrow-assignment-expression-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-arrow-assignment-expression-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-arrow-assignment-expression-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-arrow-assignment-expression-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-arrow-import-then-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-arrow-import-then-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-arrow-import-then-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-arrow-import-then-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-arrow-import-then-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-arrow-import-then-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-await-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-await-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-await-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-await-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-await-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-await-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-return-await-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-return-await-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-return-await-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-return-await-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-return-await-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-async-arrow-function-return-await-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-async-function-await-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-async-function-await-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-async-function-await-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-async-function-await-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-async-function-await-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-async-function-await-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-async-function-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-async-function-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-async-function-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-async-function-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-async-function-return-await-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-async-function-return-await-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-async-function-return-await-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-async-function-return-await-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-async-function-return-await-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-async-function-return-await-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-async-function-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-async-function-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-async-gen-await-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-async-gen-await-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-async-gen-await-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-async-gen-await-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-async-gen-await-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-async-gen-await-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-async-gen-return-await-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-async-gen-return-await-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-async-gen-return-await-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-async-gen-return-await-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-async-gen-return-await-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-async-gen-return-await-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-block-import-then-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-block-import-then-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-block-import-then-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-block-import-then-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-block-import-then-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-block-import-then-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-do-while-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-do-while-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-do-while-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-do-while-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-do-while-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-do-while-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-else-import-then-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-else-import-then-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-else-import-then-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-else-import-then-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-else-import-then-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-else-import-then-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-function-import-then-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-function-import-then-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-function-import-then-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-function-import-then-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-function-import-then-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-function-import-then-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-if-braceless-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-if-braceless-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-if-braceless-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-if-braceless-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-if-braceless-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-if-braceless-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-if-import-then-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-if-import-then-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-if-import-then-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-if-import-then-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-if-import-then-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-if-import-then-specifier-tostring.js
+language/expressions/dynamic-import/usage/nested-while-import-then-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/nested-while-import-then-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/nested-while-import-then-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/nested-while-import-then-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/nested-while-import-then-returns-thenable.js
+language/expressions/dynamic-import/usage/nested-while-import-then-specifier-tostring.js
+language/expressions/dynamic-import/usage/syntax-nested-block-labeled-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/syntax-nested-block-labeled-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/syntax-nested-block-labeled-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/syntax-nested-block-labeled-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/syntax-nested-block-labeled-returns-thenable.js
+language/expressions/dynamic-import/usage/syntax-nested-block-labeled-specifier-tostring.js
+language/expressions/dynamic-import/usage/top-level-import-then-eval-gtbndng-indirect-update-dflt.js
+language/expressions/dynamic-import/usage/top-level-import-then-eval-gtbndng-indirect-update.js
+language/expressions/dynamic-import/usage/top-level-import-then-eval-script-code-host-resolves-module-code.js
+language/expressions/dynamic-import/usage/top-level-import-then-is-call-expression-square-brackets.js
+language/expressions/dynamic-import/usage/top-level-import-then-returns-thenable.js
+language/expressions/dynamic-import/usage/top-level-import-then-specifier-tostring.js
+language/expressions/equals/bigint-and-bigint.js
+language/expressions/equals/bigint-and-boolean.js
+language/expressions/equals/bigint-and-incomparable-primitive.js
+language/expressions/equals/bigint-and-non-finite.js
+language/expressions/equals/bigint-and-number-extremes.js
+language/expressions/equals/bigint-and-number.js
+language/expressions/equals/bigint-and-object.js
+language/expressions/equals/bigint-and-string.js
+language/expressions/exponentiation/bigint-and-number.js
+language/expressions/exponentiation/bigint-arithmetic.js
+language/expressions/exponentiation/bigint-errors.js
+language/expressions/exponentiation/bigint-negative-exponent-throws.js
+language/expressions/exponentiation/bigint-toprimitive.js
+language/expressions/exponentiation/bigint-wrapped-values.js
+language/expressions/exponentiation/bigint-zero-base-zero-exponent.js
+language/expressions/greater-than-or-equal/bigint-and-bigint.js
+language/expressions/greater-than-or-equal/bigint-and-incomparable-string.js
+language/expressions/greater-than-or-equal/bigint-and-non-finite.js
+language/expressions/greater-than-or-equal/bigint-and-number-extremes.js
+language/expressions/greater-than-or-equal/bigint-and-number.js
+language/expressions/greater-than-or-equal/bigint-and-string.js
+language/expressions/greater-than/bigint-and-bigint.js
+language/expressions/greater-than/bigint-and-boolean.js
+language/expressions/greater-than/bigint-and-incomparable-string.js
+language/expressions/greater-than/bigint-and-non-finite.js
+language/expressions/greater-than/bigint-and-number-extremes.js
+language/expressions/greater-than/bigint-and-number.js
+language/expressions/greater-than/bigint-and-string.js
+language/expressions/greater-than/bigint-and-symbol.js
+language/expressions/import.meta/distinct-for-each-module.js
+language/expressions/import.meta/import-meta-is-an-ordinary-object.js
+language/expressions/import.meta/same-object-returned.js
+language/expressions/import.meta/syntax/goal-module-nested-function.js
+language/expressions/import.meta/syntax/goal-module.js
+language/expressions/left-shift/bigint-and-number.js
+language/expressions/left-shift/bigint-errors.js
+language/expressions/left-shift/bigint-non-primitive.js
+language/expressions/left-shift/bigint-toprimitive.js
+language/expressions/left-shift/bigint-wrapped-values.js
+language/expressions/left-shift/bigint.js
+language/expressions/less-than-or-equal/bigint-and-bigint.js
+language/expressions/less-than-or-equal/bigint-and-incomparable-string.js
+language/expressions/less-than-or-equal/bigint-and-non-finite.js
+language/expressions/less-than-or-equal/bigint-and-number-extremes.js
+language/expressions/less-than-or-equal/bigint-and-number.js
+language/expressions/less-than-or-equal/bigint-and-string.js
+language/expressions/less-than/bigint-and-bigint.js
+language/expressions/less-than/bigint-and-boolean.js
+language/expressions/less-than/bigint-and-incomparable-string.js
+language/expressions/less-than/bigint-and-non-finite.js
+language/expressions/less-than/bigint-and-number-extremes.js
+language/expressions/less-than/bigint-and-number.js
+language/expressions/less-than/bigint-and-string.js
+language/expressions/less-than/bigint-and-symbol.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-bigint.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-lhs-before-rhs.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-namedevaluation-arrow-function.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-namedevaluation-class-expression.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-namedevaluation-function.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-no-set-put.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-no-set.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-non-extensible.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-non-writeable-put.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-non-writeable.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-unresolved-lhs.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-unresolved-rhs-put.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator-unresolved-rhs.js
+language/expressions/logical-assignment/lgcl-and-assignment-operator.js
+language/expressions/logical-assignment/lgcl-and-whitespace.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-bigint.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-lhs-before-rhs.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-namedevaluation-arrow-function.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-namedevaluation-class-expression.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-namedevaluation-function.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-no-set-put.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-no-set.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-extensible.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-writeable-put.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-writeable.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-unresolved-lhs.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-unresolved-rhs-put.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator-unresolved-rhs.js
+language/expressions/logical-assignment/lgcl-nullish-assignment-operator.js
+language/expressions/logical-assignment/lgcl-nullish-whitespace.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-bigint.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-lhs-before-rhs.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-namedevaluation-arrow-function.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-namedevaluation-class-expression.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-namedevaluation-function.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-no-set-put.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-no-set.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-non-extensible.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-non-writeable-put.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-non-writeable.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-unresolved-lhs.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-unresolved-rhs-put.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator-unresolved-rhs.js
+language/expressions/logical-assignment/lgcl-or-assignment-operator.js
+language/expressions/logical-assignment/lgcl-or-whitespace.js
+language/expressions/logical-not/bigint.js
+language/expressions/modulus/bigint-and-number.js
+language/expressions/modulus/bigint-arithmetic.js
+language/expressions/modulus/bigint-errors.js
+language/expressions/modulus/bigint-modulo-zero.js
+language/expressions/modulus/bigint-toprimitive.js
+language/expressions/modulus/bigint-wrapped-values.js
+language/expressions/multiplication/bigint-and-number.js
+language/expressions/multiplication/bigint-arithmetic.js
+language/expressions/multiplication/bigint-errors.js
+language/expressions/multiplication/bigint-toprimitive.js
+language/expressions/multiplication/bigint-wrapped-values.js
+language/expressions/object/literal-property-name-bigint.js
+language/expressions/postfix-decrement/bigint.js
+language/expressions/postfix-increment/bigint.js
+language/expressions/prefix-decrement/bigint.js
+language/expressions/prefix-increment/bigint.js
+language/expressions/right-shift/bigint-and-number.js
+language/expressions/right-shift/bigint-errors.js
+language/expressions/right-shift/bigint-non-primitive.js
+language/expressions/right-shift/bigint-toprimitive.js
+language/expressions/right-shift/bigint-wrapped-values.js
+language/expressions/right-shift/bigint.js
+language/expressions/strict-does-not-equals/bigint-and-bigint.js
+language/expressions/strict-does-not-equals/bigint-and-boolean.js
+language/expressions/strict-does-not-equals/bigint-and-incomparable-primitive.js
+language/expressions/strict-does-not-equals/bigint-and-non-finite.js
+language/expressions/strict-does-not-equals/bigint-and-number-extremes.js
+language/expressions/strict-does-not-equals/bigint-and-number.js
+language/expressions/strict-does-not-equals/bigint-and-object.js
+language/expressions/strict-does-not-equals/bigint-and-string.js
+language/expressions/strict-equals/bigint-and-bigint.js
+language/expressions/strict-equals/bigint-and-boolean.js
+language/expressions/strict-equals/bigint-and-incomparable-primitive.js
+language/expressions/strict-equals/bigint-and-non-finite.js
+language/expressions/strict-equals/bigint-and-number-extremes.js
+language/expressions/strict-equals/bigint-and-number.js
+language/expressions/strict-equals/bigint-and-object.js
+language/expressions/strict-equals/bigint-and-string.js
+language/expressions/subtraction/bigint-and-number.js
+language/expressions/subtraction/bigint-arithmetic.js
+language/expressions/subtraction/bigint-errors.js
+language/expressions/subtraction/bigint-toprimitive.js
+language/expressions/subtraction/bigint-wrapped-values.js
+language/expressions/tagged-template/invalid-escape-sequences.js
+language/expressions/typeof/bigint.js
+language/expressions/unary-minus/bigint-non-primitive.js
+language/expressions/unary-minus/bigint.js
+language/expressions/unary-plus/bigint-throws.js
+language/expressions/unsigned-right-shift/bigint-and-number.js
+language/expressions/unsigned-right-shift/bigint-errors.js
+language/expressions/unsigned-right-shift/bigint-non-primitive.js
+language/expressions/unsigned-right-shift/bigint-toprimitive.js
+language/expressions/unsigned-right-shift/bigint-wrapped-values.js
+language/expressions/unsigned-right-shift/bigint.js
+language/identifiers/part-unicode-10.0.0-escaped.js
+language/identifiers/part-unicode-10.0.0.js
+language/identifiers/part-unicode-11.0.0-escaped.js
+language/identifiers/part-unicode-11.0.0.js
+language/identifiers/part-unicode-12.0.0-escaped.js
+language/identifiers/part-unicode-12.0.0.js
+language/identifiers/part-unicode-13.0.0-escaped.js
+language/identifiers/part-unicode-13.0.0.js
+language/identifiers/part-unicode-7.0.0-escaped.js
+language/identifiers/part-unicode-7.0.0.js
+language/identifiers/part-unicode-8.0.0-escaped.js
+language/identifiers/part-unicode-8.0.0.js
+language/identifiers/part-unicode-9.0.0-escaped.js
+language/identifiers/part-unicode-9.0.0.js
+language/identifiers/start-unicode-10.0.0-escaped.js
+language/identifiers/start-unicode-10.0.0.js
+language/identifiers/start-unicode-11.0.0-escaped.js
+language/identifiers/start-unicode-11.0.0.js
+language/identifiers/start-unicode-12.0.0-escaped.js
+language/identifiers/start-unicode-12.0.0.js
+language/identifiers/start-unicode-13.0.0-escaped.js
+language/identifiers/start-unicode-13.0.0.js
+language/identifiers/start-unicode-5.2.0-escaped.js
+language/identifiers/start-unicode-5.2.0.js
+language/identifiers/start-unicode-6.1.0-escaped.js
+language/identifiers/start-unicode-6.1.0.js
+language/identifiers/start-unicode-7.0.0-escaped.js
+language/identifiers/start-unicode-7.0.0.js
+language/identifiers/start-unicode-8.0.0-escaped.js
+language/identifiers/start-unicode-8.0.0.js
+language/identifiers/start-unicode-9.0.0-escaped.js
+language/identifiers/start-unicode-9.0.0.js
+language/literals/bigint/mv-is-not-integer-dot-dds.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bds.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bd.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bds.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dd-one-of.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dd.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hds.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hd.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hds.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-hil-od-nsl-od-one-of.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd-one-of.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-one-of.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-ods.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-od.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-ods.js
+language/literals/bigint/numeric-separators/numeric-separator-literal-sign-minus-dds-nsl-dd.js
+language/literals/regexp/early-err-bad-flag.js
+language/literals/regexp/named-groups/invalid-dangling-groupname-4-u.js
+language/literals/regexp/named-groups/invalid-dangling-groupname-4.js
+language/literals/regexp/named-groups/invalid-dangling-groupname-5.js
+language/literals/regexp/named-groups/invalid-dangling-groupname-without-group-u.js
+language/literals/regexp/named-groups/invalid-incomplete-groupname-4.js
+language/literals/regexp/named-groups/invalid-incomplete-groupname-5.js
+language/literals/regexp/named-groups/invalid-incomplete-groupname-6.js
+language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-2-u.js
+language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-3-u.js
+language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-u.js
+language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2-u.js
+language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2.js
+language/module-code/early-export-global.js
+language/module-code/early-export-unresolvable.js
+language/module-code/eval-export-dflt-cls-anon-semi.js
+language/module-code/eval-export-dflt-cls-anon.js
+language/module-code/eval-export-dflt-cls-name-meth.js
+language/module-code/eval-export-dflt-cls-named.js
+language/module-code/eval-export-dflt-expr-cls-anon.js
+language/module-code/eval-export-dflt-expr-cls-name-meth.js
+language/module-code/eval-export-dflt-expr-cls-named.js
+language/module-code/eval-export-dflt-expr-fn-anon.js
+language/module-code/eval-export-dflt-expr-fn-named.js
+language/module-code/eval-export-dflt-expr-gen-anon.js
+language/module-code/eval-export-dflt-expr-gen-named.js
+language/module-code/eval-export-dflt-expr-in.js
+language/module-code/eval-gtbndng-indirect-update-dflt.js
+language/module-code/eval-rqstd-once.js
+language/module-code/eval-rqstd-order.js
+language/module-code/eval-self-once.js
+language/module-code/export-star-as-dflt.js
+language/module-code/instn-named-bndng-dflt-cls.js
+language/module-code/instn-named-bndng-dflt-expr.js
+language/module-code/instn-named-bndng-dflt-fun-anon.js
+language/module-code/instn-named-bndng-dflt-fun-named.js
+language/module-code/instn-named-bndng-dflt-gen-anon.js
+language/module-code/instn-named-bndng-dflt-gen-named.js
+language/module-code/instn-named-err-dflt-thru-star-dflt.js
+language/module-code/instn-named-err-not-found-dflt.js
+language/module-code/instn-once.js
+language/module-code/privatename-valid-no-earlyerr.js
+language/module-code/top-level-await/await-awaits-thenable-not-callable.js
+language/module-code/top-level-await/await-awaits-thenables-that-throw.js
+language/module-code/top-level-await/await-awaits-thenables.js
+language/module-code/top-level-await/await-dynamic-import-rejection.js
+language/module-code/top-level-await/await-dynamic-import-resolution.js
+language/module-code/top-level-await/await-expr-func-expression.js
+language/module-code/top-level-await/await-expr-new-expr-reject.js
+language/module-code/top-level-await/await-expr-new-expr.js
+language/module-code/top-level-await/await-expr-reject-throws.js
+language/module-code/top-level-await/await-expr-resolution.js
+language/module-code/top-level-await/await-void-expr.js
+language/module-code/top-level-await/dynamic-import-rejection.js
+language/module-code/top-level-await/dynamic-import-resolution.js
+language/module-code/top-level-await/if-await-expr.js
+language/module-code/top-level-await/module-async-import-async-resolution-ticks.js
+language/module-code/top-level-await/module-import-rejection-body.js
+language/module-code/top-level-await/module-import-rejection-tick.js
+language/module-code/top-level-await/module-import-resolution.js
+language/module-code/top-level-await/module-import-unwrapped.js
+language/module-code/top-level-await/module-self-import-async-resolution-ticks.js
+language/module-code/top-level-await/module-sync-import-async-resolution-ticks.js
+language/module-code/top-level-await/no-operand.js
+language/module-code/top-level-await/syntax/await-expr-dyn-import.js
+language/module-code/top-level-await/syntax/block-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/block-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/block-await-expr-identifier.js
+language/module-code/top-level-await/syntax/block-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/block-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/block-await-expr-nested.js
+language/module-code/top-level-await/syntax/block-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/block-await-expr-null.js
+language/module-code/top-level-await/syntax/block-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/block-await-expr-regexp.js
+language/module-code/top-level-await/syntax/block-await-expr-this.js
+language/module-code/top-level-await/syntax/catch-parameter.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-identifier.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-nested.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-null.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-regexp.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-this.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-identifier.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-nested.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-null.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-regexp.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-this.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-identifier.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-nested.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-null.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-regexp.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/export-dft-class-decl-await-expr-this.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-identifier.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-nested.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-null.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-regexp.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-this.js
+language/module-code/top-level-await/syntax/export-var-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/export-var-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/export-var-await-expr-identifier.js
+language/module-code/top-level-await/syntax/export-var-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/export-var-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/export-var-await-expr-nested.js
+language/module-code/top-level-await/syntax/export-var-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/export-var-await-expr-null.js
+language/module-code/top-level-await/syntax/export-var-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/export-var-await-expr-regexp.js
+language/module-code/top-level-await/syntax/export-var-await-expr-this.js
+language/module-code/top-level-await/syntax/for-await-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/for-await-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/for-await-await-expr-identifier.js
+language/module-code/top-level-await/syntax/for-await-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/for-await-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/for-await-await-expr-nested.js
+language/module-code/top-level-await/syntax/for-await-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/for-await-await-expr-null.js
+language/module-code/top-level-await/syntax/for-await-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/for-await-await-expr-regexp.js
+language/module-code/top-level-await/syntax/for-await-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/for-await-await-expr-this.js
+language/module-code/top-level-await/syntax/for-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/for-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/for-await-expr-identifier.js
+language/module-code/top-level-await/syntax/for-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/for-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/for-await-expr-nested.js
+language/module-code/top-level-await/syntax/for-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/for-await-expr-null.js
+language/module-code/top-level-await/syntax/for-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/for-await-expr-regexp.js
+language/module-code/top-level-await/syntax/for-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/for-await-expr-this.js
+language/module-code/top-level-await/syntax/for-in-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/for-in-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/for-in-await-expr-identifier.js
+language/module-code/top-level-await/syntax/for-in-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/for-in-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/for-in-await-expr-nested.js
+language/module-code/top-level-await/syntax/for-in-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/for-in-await-expr-null.js
+language/module-code/top-level-await/syntax/for-in-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/for-in-await-expr-regexp.js
+language/module-code/top-level-await/syntax/for-in-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/for-in-await-expr-this.js
+language/module-code/top-level-await/syntax/for-of-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/for-of-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/for-of-await-expr-identifier.js
+language/module-code/top-level-await/syntax/for-of-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/for-of-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/for-of-await-expr-nested.js
+language/module-code/top-level-await/syntax/for-of-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/for-of-await-expr-null.js
+language/module-code/top-level-await/syntax/for-of-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/for-of-await-expr-regexp.js
+language/module-code/top-level-await/syntax/for-of-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/for-of-await-expr-this.js
+language/module-code/top-level-await/syntax/if-block-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/if-block-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/if-block-await-expr-identifier.js
+language/module-code/top-level-await/syntax/if-block-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/if-block-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/if-block-await-expr-nested.js
+language/module-code/top-level-await/syntax/if-block-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/if-block-await-expr-null.js
+language/module-code/top-level-await/syntax/if-block-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/if-block-await-expr-regexp.js
+language/module-code/top-level-await/syntax/if-block-await-expr-this.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-identifier.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-nested.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-null.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-regexp.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-this.js
+language/module-code/top-level-await/syntax/top-level-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/top-level-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/top-level-await-expr-identifier.js
+language/module-code/top-level-await/syntax/top-level-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/top-level-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/top-level-await-expr-nested.js
+language/module-code/top-level-await/syntax/top-level-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/top-level-await-expr-null.js
+language/module-code/top-level-await/syntax/top-level-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/top-level-await-expr-regexp.js
+language/module-code/top-level-await/syntax/top-level-await-expr-this.js
+language/module-code/top-level-await/syntax/try-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/try-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/try-await-expr-identifier.js
+language/module-code/top-level-await/syntax/try-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/try-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/try-await-expr-nested.js
+language/module-code/top-level-await/syntax/try-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/try-await-expr-null.js
+language/module-code/top-level-await/syntax/try-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/try-await-expr-regexp.js
+language/module-code/top-level-await/syntax/try-await-expr-this.js
+language/module-code/top-level-await/syntax/typeof-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/typeof-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/typeof-await-expr-identifier.js
+language/module-code/top-level-await/syntax/typeof-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/typeof-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/typeof-await-expr-nested.js
+language/module-code/top-level-await/syntax/typeof-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/typeof-await-expr-null.js
+language/module-code/top-level-await/syntax/typeof-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/typeof-await-expr-regexp.js
+language/module-code/top-level-await/syntax/typeof-await-expr-this.js
+language/module-code/top-level-await/syntax/void-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/void-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/void-await-expr-identifier.js
+language/module-code/top-level-await/syntax/void-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/void-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/void-await-expr-nested.js
+language/module-code/top-level-await/syntax/void-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/void-await-expr-null.js
+language/module-code/top-level-await/syntax/void-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/void-await-expr-regexp.js
+language/module-code/top-level-await/syntax/void-await-expr-this.js
+language/module-code/top-level-await/syntax/while-await-expr-array-literal.js
+language/module-code/top-level-await/syntax/while-await-expr-func-expression.js
+language/module-code/top-level-await/syntax/while-await-expr-identifier.js
+language/module-code/top-level-await/syntax/while-await-expr-literal-number.js
+language/module-code/top-level-await/syntax/while-await-expr-literal-string.js
+language/module-code/top-level-await/syntax/while-await-expr-nested.js
+language/module-code/top-level-await/syntax/while-await-expr-new-expr.js
+language/module-code/top-level-await/syntax/while-await-expr-null.js
+language/module-code/top-level-await/syntax/while-await-expr-obj-literal.js
+language/module-code/top-level-await/syntax/while-await-expr-regexp.js
+language/module-code/top-level-await/syntax/while-await-expr-this.js
+language/module-code/top-level-await/top-level-ticks-2.js
+language/module-code/top-level-await/top-level-ticks.js
+language/module-code/top-level-await/void-await-expr.js
+language/module-code/top-level-await/while-dynamic-evaluation.js
+language/statements/class/classelementname-abrupt-completion.js
+language/statements/class/dstr/async-private-gen-meth-ary-init-iter-close.js
+language/statements/class/dstr/async-private-gen-meth-ary-init-iter-no-close.js
+language/statements/class/dstr/async-private-gen-meth-ary-name-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-elision.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-id.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-init-iter-close.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-init-iter-no-close.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-name-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-elision.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-id.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-ary.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-prop-obj.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-rest-getter.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/async-private-gen-meth-dflt-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-ary.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-prop-obj.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-rest-getter.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/async-private-gen-meth-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-init-iter-close.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-init-iter-no-close.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-name-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-elision.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-id.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-init-iter-close.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-init-iter-no-close.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-name-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-elision.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-id.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-ary.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-prop-obj.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-rest-getter.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/async-private-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-empty.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-ary.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-id.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-prop-obj.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-rest-getter.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/async-private-gen-meth-static-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-gen-meth-ary-init-iter-close.js
+language/statements/class/dstr/private-gen-meth-ary-init-iter-no-close.js
+language/statements/class/dstr/private-gen-meth-ary-name-iter-val.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-elision.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-gen-meth-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-init-iter-close.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-init-iter-no-close.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-name-iter-val.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-elision.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-gen-meth-dflt-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-gen-meth-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-gen-meth-static-ary-init-iter-close.js
+language/statements/class/dstr/private-gen-meth-static-ary-init-iter-no-close.js
+language/statements/class/dstr/private-gen-meth-static-ary-name-iter-val.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-elision.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-init-iter-close.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-init-iter-no-close.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-name-iter-val.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-elision.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-empty.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-gen-meth-static-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-meth-ary-init-iter-close.js
+language/statements/class/dstr/private-meth-ary-init-iter-no-close.js
+language/statements/class/dstr/private-meth-ary-name-iter-val.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-meth-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-meth-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-meth-ary-ptrn-elision.js
+language/statements/class/dstr/private-meth-ary-ptrn-empty.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-meth-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-meth-dflt-ary-init-iter-close.js
+language/statements/class/dstr/private-meth-dflt-ary-init-iter-no-close.js
+language/statements/class/dstr/private-meth-dflt-ary-name-iter-val.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-elision.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-empty.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-meth-dflt-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-empty.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-meth-dflt-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-meth-obj-ptrn-empty.js
+language/statements/class/dstr/private-meth-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-meth-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-meth-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-meth-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-meth-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-meth-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-meth-static-ary-init-iter-close.js
+language/statements/class/dstr/private-meth-static-ary-init-iter-no-close.js
+language/statements/class/dstr/private-meth-static-ary-name-iter-val.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-elision.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-empty.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-meth-static-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-meth-static-dflt-ary-init-iter-close.js
+language/statements/class/dstr/private-meth-static-dflt-ary-init-iter-no-close.js
+language/statements/class/dstr/private-meth-static-dflt-ary-name-iter-val.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-id.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elision-exhausted.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-elision.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-empty.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-elem.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-elision.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-empty.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-ary-rest.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-id-elision.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-id.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-obj-id.js
+language/statements/class/dstr/private-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-empty.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-meth-static-dflt-obj-ptrn-rest-val-obj.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-empty.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-arrow.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-class.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-cover.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-fn.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-id-init-fn-name-gen.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-id-init-skipped.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-id-trailing-comma.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-ary-init.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-ary-trailing-comma.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-ary.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-id-init-skipped.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-id-init.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-id-trailing-comma.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-id.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-obj-init.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-prop-obj.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-rest-getter.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-rest-skip-non-enumerable.js
+language/statements/class/dstr/private-meth-static-obj-ptrn-rest-val-obj.js
+language/statements/class/elements/after-same-line-gen-computed-names.js
+language/statements/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/after-same-line-gen-private-field-usage.js
+language/statements/class/elements/after-same-line-gen-private-method-getter-usage.js
+language/statements/class/elements/after-same-line-gen-private-method-usage.js
+language/statements/class/elements/after-same-line-gen-private-names.js
+language/statements/class/elements/after-same-line-gen-rs-private-getter-alt.js
+language/statements/class/elements/after-same-line-gen-rs-private-getter.js
+language/statements/class/elements/after-same-line-gen-rs-private-method-alt.js
+language/statements/class/elements/after-same-line-gen-rs-private-method.js
+language/statements/class/elements/after-same-line-gen-rs-private-setter-alt.js
+language/statements/class/elements/after-same-line-gen-rs-private-setter.js
+language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-gen-rs-privatename-identifier.js
+language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
+language/statements/class/elements/after-same-line-gen-static-private-fields.js
+language/statements/class/elements/after-same-line-gen-static-private-methods-with-fields.js
+language/statements/class/elements/after-same-line-gen-static-private-methods.js
+language/statements/class/elements/after-same-line-gen-string-literal-names.js
+language/statements/class/elements/after-same-line-method-computed-names.js
+language/statements/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/after-same-line-method-private-field-usage.js
+language/statements/class/elements/after-same-line-method-private-method-getter-usage.js
+language/statements/class/elements/after-same-line-method-private-method-usage.js
+language/statements/class/elements/after-same-line-method-private-names.js
+language/statements/class/elements/after-same-line-method-rs-private-getter-alt.js
+language/statements/class/elements/after-same-line-method-rs-private-getter.js
+language/statements/class/elements/after-same-line-method-rs-private-method-alt.js
+language/statements/class/elements/after-same-line-method-rs-private-method.js
+language/statements/class/elements/after-same-line-method-rs-private-setter-alt.js
+language/statements/class/elements/after-same-line-method-rs-private-setter.js
+language/statements/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-method-rs-privatename-identifier.js
+language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier.js
+language/statements/class/elements/after-same-line-method-static-private-fields.js
+language/statements/class/elements/after-same-line-method-static-private-methods-with-fields.js
+language/statements/class/elements/after-same-line-method-static-private-methods.js
+language/statements/class/elements/after-same-line-method-string-literal-names.js
+language/statements/class/elements/after-same-line-static-async-gen-computed-names.js
+language/statements/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/after-same-line-static-async-gen-private-field-usage.js
+language/statements/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
+language/statements/class/elements/after-same-line-static-async-gen-private-method-usage.js
+language/statements/class/elements/after-same-line-static-async-gen-private-names.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-private-method.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-gen-static-private-fields.js
+language/statements/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
+language/statements/class/elements/after-same-line-static-async-gen-static-private-methods.js
+language/statements/class/elements/after-same-line-static-async-gen-string-literal-names.js
+language/statements/class/elements/after-same-line-static-async-method-computed-names.js
+language/statements/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/after-same-line-static-async-method-private-field-usage.js
+language/statements/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
+language/statements/class/elements/after-same-line-static-async-method-private-method-usage.js
+language/statements/class/elements/after-same-line-static-async-method-private-names.js
+language/statements/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-private-getter.js
+language/statements/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-private-method.js
+language/statements/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-private-setter.js
+language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-async-method-static-private-fields.js
+language/statements/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
+language/statements/class/elements/after-same-line-static-async-method-static-private-methods.js
+language/statements/class/elements/after-same-line-static-async-method-string-literal-names.js
+language/statements/class/elements/after-same-line-static-gen-computed-names.js
+language/statements/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/after-same-line-static-gen-private-field-usage.js
+language/statements/class/elements/after-same-line-static-gen-private-method-getter-usage.js
+language/statements/class/elements/after-same-line-static-gen-private-method-usage.js
+language/statements/class/elements/after-same-line-static-gen-private-names.js
+language/statements/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-private-getter.js
+language/statements/class/elements/after-same-line-static-gen-rs-private-method-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-private-method.js
+language/statements/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-private-setter.js
+language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-gen-static-private-fields.js
+language/statements/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
+language/statements/class/elements/after-same-line-static-gen-static-private-methods.js
+language/statements/class/elements/after-same-line-static-gen-string-literal-names.js
+language/statements/class/elements/after-same-line-static-method-computed-names.js
+language/statements/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/after-same-line-static-method-private-field-usage.js
+language/statements/class/elements/after-same-line-static-method-private-method-getter-usage.js
+language/statements/class/elements/after-same-line-static-method-private-method-usage.js
+language/statements/class/elements/after-same-line-static-method-private-names.js
+language/statements/class/elements/after-same-line-static-method-rs-private-getter-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-private-getter.js
+language/statements/class/elements/after-same-line-static-method-rs-private-method-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-private-method.js
+language/statements/class/elements/after-same-line-static-method-rs-private-setter-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-private-setter.js
+language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
+language/statements/class/elements/after-same-line-static-method-static-private-fields.js
+language/statements/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
+language/statements/class/elements/after-same-line-static-method-static-private-methods.js
+language/statements/class/elements/after-same-line-static-method-string-literal-names.js
+language/statements/class/elements/arrow-fnc-init-err-contains-arguments.js
+language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
+language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
+language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
+language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
+language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
+language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
+language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
+language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
+language/statements/class/elements/async-gen-private-method-static/yield-spread-obj.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-async-next.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-async-return.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-async-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-sync-next.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-sync-return.js
+language/statements/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
+language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
+language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
+language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
+language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
+language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
+language/statements/class/elements/async-gen-private-method/yield-promise-reject-next.js
+language/statements/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
+language/statements/class/elements/async-gen-private-method/yield-spread-arr-single.js
+language/statements/class/elements/async-gen-private-method/yield-spread-obj.js
+language/statements/class/elements/async-gen-private-method/yield-star-async-next.js
+language/statements/class/elements/async-gen-private-method/yield-star-async-return.js
+language/statements/class/elements/async-gen-private-method/yield-star-async-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+language/statements/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
+language/statements/class/elements/async-gen-private-method/yield-star-sync-next.js
+language/statements/class/elements/async-gen-private-method/yield-star-sync-return.js
+language/statements/class/elements/async-gen-private-method/yield-star-sync-throw.js
+language/statements/class/elements/comp-name-init-err-contains-arguments.js
+language/statements/class/elements/computed-property-abrupt-completition.js
+language/statements/class/elements/equality-init-err-contains-arguments.js
+language/statements/class/elements/field-declaration.js
+language/statements/class/elements/fields-anonymous-function-length.js
+language/statements/class/elements/fields-computed-name-static-propname-constructor.js
+language/statements/class/elements/fields-computed-name-static-propname-prototype.js
+language/statements/class/elements/fields-hash-constructor-is-a-valid-name.js
+language/statements/class/elements/fields-literal-name-propname-constructor.js
+language/statements/class/elements/fields-literal-name-static-propname-constructor.js
+language/statements/class/elements/fields-string-name-propname-constructor.js
+language/statements/class/elements/fields-string-name-static-propname-constructor.js
+language/statements/class/elements/fields-string-name-static-propname-prototype.js
+language/statements/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
+language/statements/class/elements/gen-private-method-static/yield-spread-arr-single.js
+language/statements/class/elements/gen-private-method-static/yield-spread-obj.js
+language/statements/class/elements/gen-private-method/yield-spread-arr-multiple.js
+language/statements/class/elements/gen-private-method/yield-spread-arr-single.js
+language/statements/class/elements/gen-private-method/yield-spread-obj.js
+language/statements/class/elements/get-access-of-missing-private-getter.js
+language/statements/class/elements/get-access-of-missing-shadowed-private-getter.js
+language/statements/class/elements/grammar-private-field-optional-chaining.js
+language/statements/class/elements/init-value-incremental.js
+language/statements/class/elements/intercalated-static-non-static-computed-fields.js
+language/statements/class/elements/literal-name-init-err-contains-arguments.js
+language/statements/class/elements/multiple-definitions-computed-names.js
+language/statements/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/multiple-definitions-private-field-usage.js
+language/statements/class/elements/multiple-definitions-private-method-getter-usage.js
+language/statements/class/elements/multiple-definitions-private-method-usage.js
+language/statements/class/elements/multiple-definitions-private-names.js
+language/statements/class/elements/multiple-definitions-rs-private-getter-alt.js
+language/statements/class/elements/multiple-definitions-rs-private-getter.js
+language/statements/class/elements/multiple-definitions-rs-private-method-alt.js
+language/statements/class/elements/multiple-definitions-rs-private-method.js
+language/statements/class/elements/multiple-definitions-rs-private-setter-alt.js
+language/statements/class/elements/multiple-definitions-rs-private-setter.js
+language/statements/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
+language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
+language/statements/class/elements/multiple-definitions-rs-privatename-identifier.js
+language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
+language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier.js
+language/statements/class/elements/multiple-definitions-static-private-fields.js
+language/statements/class/elements/multiple-definitions-static-private-methods-with-fields.js
+language/statements/class/elements/multiple-definitions-static-private-methods.js
+language/statements/class/elements/multiple-definitions-string-literal-names.js
+language/statements/class/elements/multiple-stacked-definitions-computed-names.js
+language/statements/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/multiple-stacked-definitions-private-field-usage.js
+language/statements/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
+language/statements/class/elements/multiple-stacked-definitions-private-method-usage.js
+language/statements/class/elements/multiple-stacked-definitions-private-names.js
+language/statements/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-private-getter.js
+language/statements/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-private-method.js
+language/statements/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-private-setter.js
+language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
+language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
+language/statements/class/elements/multiple-stacked-definitions-static-private-fields.js
+language/statements/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
+language/statements/class/elements/multiple-stacked-definitions-static-private-methods.js
+language/statements/class/elements/multiple-stacked-definitions-string-literal-names.js
+language/statements/class/elements/new-no-sc-line-method-computed-names.js
+language/statements/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/new-no-sc-line-method-private-field-usage.js
+language/statements/class/elements/new-no-sc-line-method-private-method-getter-usage.js
+language/statements/class/elements/new-no-sc-line-method-private-method-usage.js
+language/statements/class/elements/new-no-sc-line-method-private-names.js
+language/statements/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-private-getter.js
+language/statements/class/elements/new-no-sc-line-method-rs-private-method-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-private-method.js
+language/statements/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-private-setter.js
+language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
+language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
+language/statements/class/elements/new-no-sc-line-method-static-private-fields.js
+language/statements/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
+language/statements/class/elements/new-no-sc-line-method-static-private-methods.js
+language/statements/class/elements/new-no-sc-line-method-string-literal-names.js
+language/statements/class/elements/new-sc-line-gen-computed-names.js
+language/statements/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/new-sc-line-gen-private-field-usage.js
+language/statements/class/elements/new-sc-line-gen-private-method-getter-usage.js
+language/statements/class/elements/new-sc-line-gen-private-method-usage.js
+language/statements/class/elements/new-sc-line-gen-private-names.js
+language/statements/class/elements/new-sc-line-gen-rs-private-getter-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-private-getter.js
+language/statements/class/elements/new-sc-line-gen-rs-private-method-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-private-method.js
+language/statements/class/elements/new-sc-line-gen-rs-private-setter-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-private-setter.js
+language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
+language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier.js
+language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
+language/statements/class/elements/new-sc-line-gen-static-private-fields.js
+language/statements/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
+language/statements/class/elements/new-sc-line-gen-static-private-methods.js
+language/statements/class/elements/new-sc-line-gen-string-literal-names.js
+language/statements/class/elements/new-sc-line-method-computed-names.js
+language/statements/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/new-sc-line-method-private-field-usage.js
+language/statements/class/elements/new-sc-line-method-private-method-getter-usage.js
+language/statements/class/elements/new-sc-line-method-private-method-usage.js
+language/statements/class/elements/new-sc-line-method-private-names.js
+language/statements/class/elements/new-sc-line-method-rs-private-getter-alt.js
+language/statements/class/elements/new-sc-line-method-rs-private-getter.js
+language/statements/class/elements/new-sc-line-method-rs-private-method-alt.js
+language/statements/class/elements/new-sc-line-method-rs-private-method.js
+language/statements/class/elements/new-sc-line-method-rs-private-setter-alt.js
+language/statements/class/elements/new-sc-line-method-rs-private-setter.js
+language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
+language/statements/class/elements/new-sc-line-method-rs-privatename-identifier.js
+language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
+language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
+language/statements/class/elements/new-sc-line-method-static-private-fields.js
+language/statements/class/elements/new-sc-line-method-static-private-methods-with-fields.js
+language/statements/class/elements/new-sc-line-method-static-private-methods.js
+language/statements/class/elements/new-sc-line-method-string-literal-names.js
+language/statements/class/elements/private-accessor-is-visible-in-computed-properties.js
+language/statements/class/elements/private-accessor-name/inst-private-escape-sequence-ZWJ.js
+language/statements/class/elements/private-accessor-name/inst-private-escape-sequence-ZWNJ.js
+language/statements/class/elements/private-accessor-name/inst-private-escape-sequence-u2118.js
+language/statements/class/elements/private-accessor-name/inst-private-escape-sequence-u6F.js
+language/statements/class/elements/private-accessor-name/inst-private-name-ZWJ.js
+language/statements/class/elements/private-accessor-name/inst-private-name-ZWNJ.js
+language/statements/class/elements/private-accessor-name/inst-private-name-common.js
+language/statements/class/elements/private-accessor-name/inst-private-name-dollar.js
+language/statements/class/elements/private-accessor-name/inst-private-name-u2118.js
+language/statements/class/elements/private-accessor-name/inst-private-name-underscore.js
+language/statements/class/elements/private-accessor-name/static-private-escape-sequence-ZWJ.js
+language/statements/class/elements/private-accessor-name/static-private-escape-sequence-ZWNJ.js
+language/statements/class/elements/private-accessor-name/static-private-escape-sequence-u2118.js
+language/statements/class/elements/private-accessor-name/static-private-escape-sequence-u6F.js
+language/statements/class/elements/private-accessor-name/static-private-name-ZWJ.js
+language/statements/class/elements/private-accessor-name/static-private-name-ZWNJ.js
+language/statements/class/elements/private-accessor-name/static-private-name-common.js
+language/statements/class/elements/private-accessor-name/static-private-name-dollar.js
+language/statements/class/elements/private-accessor-name/static-private-name-u2118.js
+language/statements/class/elements/private-accessor-name/static-private-name-underscore.js
+language/statements/class/elements/private-async-generator-method-name.js
+language/statements/class/elements/private-async-method-name.js
+language/statements/class/elements/private-class-field-on-frozen-objects.js
+language/statements/class/elements/private-derived-cls-direct-eval-contains-superproperty-1.js
+language/statements/class/elements/private-derived-cls-direct-eval-contains-superproperty-2.js
+language/statements/class/elements/private-derived-cls-direct-eval-err-contains-supercall-1.js
+language/statements/class/elements/private-derived-cls-direct-eval-err-contains-supercall-2.js
+language/statements/class/elements/private-derived-cls-direct-eval-err-contains-supercall.js
+language/statements/class/elements/private-derived-cls-indirect-eval-contains-superproperty-1.js
+language/statements/class/elements/private-derived-cls-indirect-eval-contains-superproperty-2.js
+language/statements/class/elements/private-derived-cls-indirect-eval-err-contains-supercall-1.js
+language/statements/class/elements/private-derived-cls-indirect-eval-err-contains-supercall-2.js
+language/statements/class/elements/private-derived-cls-indirect-eval-err-contains-supercall.js
+language/statements/class/elements/private-direct-eval-err-contains-arguments.js
+language/statements/class/elements/private-direct-eval-err-contains-newtarget.js
+language/statements/class/elements/private-field-access-on-inner-arrow-function.js
+language/statements/class/elements/private-field-access-on-inner-function.js
+language/statements/class/elements/private-field-after-optional-chain.js
+language/statements/class/elements/private-field-as-arrow-function.js
+language/statements/class/elements/private-field-as-async-arrow-function.js
+language/statements/class/elements/private-field-as-async-function.js
+language/statements/class/elements/private-field-as-function.js
+language/statements/class/elements/private-field-is-not-clobbered-by-computed-property.js
+language/statements/class/elements/private-field-is-visible-in-computed-properties.js
+language/statements/class/elements/private-field-on-nested-class.js
+language/statements/class/elements/private-field-visible-to-direct-eval-on-initializer.js
+language/statements/class/elements/private-field-visible-to-direct-eval.js
+language/statements/class/elements/private-field-with-initialized-id-is-visible-in-computed-properties.js
+language/statements/class/elements/private-generator-method-name.js
+language/statements/class/elements/private-getter-access-on-inner-arrow-function.js
+language/statements/class/elements/private-getter-access-on-inner-function.js
+language/statements/class/elements/private-getter-brand-check-multiple-evaluations-of-class.js
+language/statements/class/elements/private-getter-brand-check-super-class.js
+language/statements/class/elements/private-getter-brand-check.js
+language/statements/class/elements/private-getter-is-not-a-own-property.js
+language/statements/class/elements/private-getter-is-not-clobbered-by-computed-property.js
+language/statements/class/elements/private-getter-on-nested-class.js
+language/statements/class/elements/private-getter-shadowed-by-field-on-nested-class.js
+language/statements/class/elements/private-getter-shadowed-by-getter-on-nested-class.js
+language/statements/class/elements/private-getter-shadowed-by-method-on-nested-class.js
+language/statements/class/elements/private-getter-shadowed-by-setter-on-nested-class.js
+language/statements/class/elements/private-getter-visible-to-direct-eval-on-initializer.js
+language/statements/class/elements/private-getter-visible-to-direct-eval.js
+language/statements/class/elements/private-indirect-eval-err-contains-arguments.js
+language/statements/class/elements/private-indirect-eval-err-contains-newtarget.js
+language/statements/class/elements/private-method-access-on-inner-arrow-function.js
+language/statements/class/elements/private-method-access-on-inner-function.js
+language/statements/class/elements/private-method-brand-check-multiple-evaluations-of-class.js
+language/statements/class/elements/private-method-brand-check-super-class.js
+language/statements/class/elements/private-method-brand-check.js
+language/statements/class/elements/private-method-comparison-multiple-evaluations-of-class.js
+language/statements/class/elements/private-method-comparison.js
+language/statements/class/elements/private-method-get-and-call.js
+language/statements/class/elements/private-method-is-not-a-own-property.js
+language/statements/class/elements/private-method-is-not-clobbered-by-computed-property.js
+language/statements/class/elements/private-method-is-visible-in-computed-properties.js
+language/statements/class/elements/private-method-length.js
+language/statements/class/elements/private-method-on-nested-class.js
+language/statements/class/elements/private-method-referenced-from-static-method.js
+language/statements/class/elements/private-method-shadowed-by-field-on-nested-class.js
+language/statements/class/elements/private-method-shadowed-by-getter-on-nested-class.js
+language/statements/class/elements/private-method-shadowed-by-setter-on-nested-class.js
+language/statements/class/elements/private-method-shadowed-on-nested-class.js
+language/statements/class/elements/private-method-visible-to-direct-eval-on-initializer.js
+language/statements/class/elements/private-method-visible-to-direct-eval.js
+language/statements/class/elements/private-methods/prod-private-async-generator.js
+language/statements/class/elements/private-methods/prod-private-async-method.js
+language/statements/class/elements/private-methods/prod-private-generator.js
+language/statements/class/elements/private-methods/prod-private-method-initialize-order.js
+language/statements/class/elements/private-methods/prod-private-method.js
+language/statements/class/elements/private-setter-access-on-inner-arrow-function.js
+language/statements/class/elements/private-setter-access-on-inner-function.js
+language/statements/class/elements/private-setter-brand-check-multiple-evaluations-of-class.js
+language/statements/class/elements/private-setter-brand-check-super-class.js
+language/statements/class/elements/private-setter-brand-check.js
+language/statements/class/elements/private-setter-is-not-a-own-property.js
+language/statements/class/elements/private-setter-is-not-clobbered-by-computed-property.js
+language/statements/class/elements/private-setter-on-nested-class.js
+language/statements/class/elements/private-setter-shadowed-by-field-on-nested-class.js
+language/statements/class/elements/private-setter-shadowed-by-getter-on-nested-class.js
+language/statements/class/elements/private-setter-shadowed-by-method-on-nested-class.js
+language/statements/class/elements/private-setter-shadowed-by-setter-on-nested-class.js
+language/statements/class/elements/private-setter-visible-to-direct-eval-on-initializer.js
+language/statements/class/elements/private-setter-visible-to-direct-eval.js
+language/statements/class/elements/private-static-async-generator-method-name.js
+language/statements/class/elements/private-static-async-method-name.js
+language/statements/class/elements/private-static-field-shadowed-by-field-on-nested-class.js
+language/statements/class/elements/private-static-field-shadowed-by-getter-on-nested-class.js
+language/statements/class/elements/private-static-field-shadowed-by-method-on-nested-class.js
+language/statements/class/elements/private-static-field-shadowed-by-setter-on-nested-class.js
+language/statements/class/elements/private-static-field-usage-inside-nested-class.js
+language/statements/class/elements/private-static-field-visible-to-direct-eval.js
+language/statements/class/elements/private-static-generator-method-name.js
+language/statements/class/elements/private-static-getter-abrupt-completition.js
+language/statements/class/elements/private-static-getter-visible-to-direct-eval.js
+language/statements/class/elements/private-static-method-length.js
+language/statements/class/elements/private-static-method-name.js
+language/statements/class/elements/private-static-method-shadowed-by-field-on-nested-class.js
+language/statements/class/elements/private-static-method-shadowed-by-getter-on-nested-class.js
+language/statements/class/elements/private-static-method-shadowed-by-method-on-nested-class.js
+language/statements/class/elements/private-static-method-shadowed-by-setter-on-nested-class.js
+language/statements/class/elements/private-static-method-usage-inside-nested-class.js
+language/statements/class/elements/private-static-method-visible-to-direct-eval.js
+language/statements/class/elements/private-static-setter-abrupt-completition.js
+language/statements/class/elements/private-static-setter-visible-to-direct-eval.js
+language/statements/class/elements/privatefield-on-proxy.js
+language/statements/class/elements/privatefieldadd-typeerror.js
+language/statements/class/elements/privatefieldget-success-1.js
+language/statements/class/elements/privatefieldget-success-2.js
+language/statements/class/elements/privatefieldget-success-3.js
+language/statements/class/elements/privatefieldget-success-4.js
+language/statements/class/elements/privatefieldget-success-5.js
+language/statements/class/elements/privatefieldget-typeerror-1.js
+language/statements/class/elements/privatefieldget-typeerror-2.js
+language/statements/class/elements/privatefieldget-typeerror-3.js
+language/statements/class/elements/privatefieldget-typeerror-4.js
+language/statements/class/elements/privatefieldget-typeerror-5.js
+language/statements/class/elements/privatefieldset-typeerror-1.js
+language/statements/class/elements/privatefieldset-typeerror-2.js
+language/statements/class/elements/privatefieldset-typeerror-3.js
+language/statements/class/elements/privatefieldset-typeerror-4.js
+language/statements/class/elements/privatefieldset-typeerror-5.js
+language/statements/class/elements/privategetter-on-proxy.js
+language/statements/class/elements/privatemethods-on-proxy.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-4.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-5.js
+language/statements/class/elements/privatename-valid-no-earlyerr.js
+language/statements/class/elements/prod-private-getter-before-super-return-in-constructor.js
+language/statements/class/elements/prod-private-getter-before-super-return-in-field-initializer.js
+language/statements/class/elements/prod-private-method-before-super-return-in-constructor.js
+language/statements/class/elements/prod-private-method-before-super-return-in-field-initializer.js
+language/statements/class/elements/prod-private-setter-before-super-return-in-constructor.js
+language/statements/class/elements/prod-private-setter-before-super-return-in-field-initializer.js
+language/statements/class/elements/redeclaration.js
+language/statements/class/elements/regular-definitions-computed-names.js
+language/statements/class/elements/regular-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/regular-definitions-private-field-usage.js
+language/statements/class/elements/regular-definitions-private-method-getter-usage.js
+language/statements/class/elements/regular-definitions-private-method-usage.js
+language/statements/class/elements/regular-definitions-private-names.js
+language/statements/class/elements/regular-definitions-rs-private-getter-alt.js
+language/statements/class/elements/regular-definitions-rs-private-getter.js
+language/statements/class/elements/regular-definitions-rs-private-method-alt.js
+language/statements/class/elements/regular-definitions-rs-private-method.js
+language/statements/class/elements/regular-definitions-rs-private-setter-alt.js
+language/statements/class/elements/regular-definitions-rs-private-setter.js
+language/statements/class/elements/regular-definitions-rs-privatename-identifier-alt.js
+language/statements/class/elements/regular-definitions-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/regular-definitions-rs-privatename-identifier-initializer.js
+language/statements/class/elements/regular-definitions-rs-privatename-identifier.js
+language/statements/class/elements/regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/regular-definitions-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/regular-definitions-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/regular-definitions-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/regular-definitions-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/regular-definitions-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/regular-definitions-rs-static-method-privatename-identifier.js
+language/statements/class/elements/regular-definitions-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/regular-definitions-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/regular-definitions-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/regular-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/regular-definitions-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/regular-definitions-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/regular-definitions-rs-static-privatename-identifier.js
+language/statements/class/elements/regular-definitions-static-private-fields.js
+language/statements/class/elements/regular-definitions-static-private-methods-with-fields.js
+language/statements/class/elements/regular-definitions-static-private-methods.js
+language/statements/class/elements/regular-definitions-string-literal-names.js
+language/statements/class/elements/same-line-async-gen-computed-names.js
+language/statements/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/same-line-async-gen-private-field-usage.js
+language/statements/class/elements/same-line-async-gen-private-method-getter-usage.js
+language/statements/class/elements/same-line-async-gen-private-method-usage.js
+language/statements/class/elements/same-line-async-gen-private-names.js
+language/statements/class/elements/same-line-async-gen-rs-private-getter-alt.js
+language/statements/class/elements/same-line-async-gen-rs-private-getter.js
+language/statements/class/elements/same-line-async-gen-rs-private-method-alt.js
+language/statements/class/elements/same-line-async-gen-rs-private-method.js
+language/statements/class/elements/same-line-async-gen-rs-private-setter-alt.js
+language/statements/class/elements/same-line-async-gen-rs-private-setter.js
+language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-async-gen-rs-privatename-identifier.js
+language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
+language/statements/class/elements/same-line-async-gen-static-private-fields.js
+language/statements/class/elements/same-line-async-gen-static-private-methods-with-fields.js
+language/statements/class/elements/same-line-async-gen-static-private-methods.js
+language/statements/class/elements/same-line-async-gen-string-literal-names.js
+language/statements/class/elements/same-line-async-method-computed-names.js
+language/statements/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/same-line-async-method-private-field-usage.js
+language/statements/class/elements/same-line-async-method-private-method-getter-usage.js
+language/statements/class/elements/same-line-async-method-private-method-usage.js
+language/statements/class/elements/same-line-async-method-private-names.js
+language/statements/class/elements/same-line-async-method-rs-private-getter-alt.js
+language/statements/class/elements/same-line-async-method-rs-private-getter.js
+language/statements/class/elements/same-line-async-method-rs-private-method-alt.js
+language/statements/class/elements/same-line-async-method-rs-private-method.js
+language/statements/class/elements/same-line-async-method-rs-private-setter-alt.js
+language/statements/class/elements/same-line-async-method-rs-private-setter.js
+language/statements/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-async-method-rs-privatename-identifier.js
+language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
+language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier.js
+language/statements/class/elements/same-line-async-method-static-private-fields.js
+language/statements/class/elements/same-line-async-method-static-private-methods-with-fields.js
+language/statements/class/elements/same-line-async-method-static-private-methods.js
+language/statements/class/elements/same-line-async-method-string-literal-names.js
+language/statements/class/elements/same-line-gen-computed-names.js
+language/statements/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/same-line-gen-private-field-usage.js
+language/statements/class/elements/same-line-gen-private-method-getter-usage.js
+language/statements/class/elements/same-line-gen-private-method-usage.js
+language/statements/class/elements/same-line-gen-private-names.js
+language/statements/class/elements/same-line-gen-rs-private-getter-alt.js
+language/statements/class/elements/same-line-gen-rs-private-getter.js
+language/statements/class/elements/same-line-gen-rs-private-method-alt.js
+language/statements/class/elements/same-line-gen-rs-private-method.js
+language/statements/class/elements/same-line-gen-rs-private-setter-alt.js
+language/statements/class/elements/same-line-gen-rs-private-setter.js
+language/statements/class/elements/same-line-gen-rs-privatename-identifier-alt.js
+language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-gen-rs-privatename-identifier.js
+language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
+language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-gen-rs-static-privatename-identifier.js
+language/statements/class/elements/same-line-gen-static-private-fields.js
+language/statements/class/elements/same-line-gen-static-private-methods-with-fields.js
+language/statements/class/elements/same-line-gen-static-private-methods.js
+language/statements/class/elements/same-line-gen-string-literal-names.js
+language/statements/class/elements/same-line-method-computed-names.js
+language/statements/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/same-line-method-private-field-usage.js
+language/statements/class/elements/same-line-method-private-method-getter-usage.js
+language/statements/class/elements/same-line-method-private-method-usage.js
+language/statements/class/elements/same-line-method-private-names.js
+language/statements/class/elements/same-line-method-rs-private-getter-alt.js
+language/statements/class/elements/same-line-method-rs-private-getter.js
+language/statements/class/elements/same-line-method-rs-private-method-alt.js
+language/statements/class/elements/same-line-method-rs-private-method.js
+language/statements/class/elements/same-line-method-rs-private-setter-alt.js
+language/statements/class/elements/same-line-method-rs-private-setter.js
+language/statements/class/elements/same-line-method-rs-privatename-identifier-alt.js
+language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-method-rs-privatename-identifier.js
+language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier.js
+language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/same-line-method-rs-static-privatename-identifier.js
+language/statements/class/elements/same-line-method-static-private-fields.js
+language/statements/class/elements/same-line-method-static-private-methods-with-fields.js
+language/statements/class/elements/same-line-method-static-private-methods.js
+language/statements/class/elements/same-line-method-string-literal-names.js
+language/statements/class/elements/set-access-of-missing-private-setter.js
+language/statements/class/elements/set-access-of-missing-shadowed-private-setter.js
+language/statements/class/elements/set-access-of-private-method.js
+language/statements/class/elements/set-access-of-shadowed-private-method.js
+language/statements/class/elements/static-as-valid-instance-field-assigned.js
+language/statements/class/elements/static-as-valid-instance-field.js
+language/statements/class/elements/static-as-valid-static-field-assigned.js
+language/statements/class/elements/static-as-valid-static-field.js
+language/statements/class/elements/static-comp-name-init-err-contains-arguments.js
+language/statements/class/elements/static-field-anonymous-function-length.js
+language/statements/class/elements/static-field-anonymous-function-name.js
+language/statements/class/elements/static-field-declaration.js
+language/statements/class/elements/static-literal-init-err-contains-arguments.js
+language/statements/class/elements/static-private-fields-proxy-default-handler-throws.js
+language/statements/class/elements/static-private-getter-access-on-inner-arrow-function.js
+language/statements/class/elements/static-private-getter-access-on-inner-class.js
+language/statements/class/elements/static-private-getter-access-on-inner-function.js
+language/statements/class/elements/static-private-getter.js
+language/statements/class/elements/static-private-method-access-on-inner-arrow-function.js
+language/statements/class/elements/static-private-method-access-on-inner-function.js
+language/statements/class/elements/static-private-method-and-instance-method-brand-check.js
+language/statements/class/elements/static-private-method-referenced-from-instance-method.js
+language/statements/class/elements/static-private-method-subclass-receiver.js
+language/statements/class/elements/static-private-setter-access-on-inner-arrow-function.js
+language/statements/class/elements/static-private-setter-access-on-inner-class.js
+language/statements/class/elements/static-private-setter-access-on-inner-function.js
+language/statements/class/elements/static-private-setter.js
+language/statements/class/elements/static-string-literal-name-init-err-contains-arguments.js
+language/statements/class/elements/string-literal-name-init-err-contains-arguments.js
+language/statements/class/elements/super-access-inside-a-private-getter.js
+language/statements/class/elements/super-access-inside-a-private-method.js
+language/statements/class/elements/super-access-inside-a-private-setter.js
+language/statements/class/elements/syntax/valid/grammar-privatemeth-duplicate-get-set.js
+language/statements/class/elements/syntax/valid/grammar-privatemeth-duplicate-meth-nestedclassmeth.js
+language/statements/class/elements/syntax/valid/grammar-privatename-classelementname-initializer-alt.js
+language/statements/class/elements/syntax/valid/grammar-privatename-classelementname-initializer.js
+language/statements/class/elements/syntax/valid/grammar-privatename-identifier.js
+language/statements/class/elements/syntax/valid/grammar-privatename-no-initializer-with-method.js
+language/statements/class/elements/syntax/valid/grammar-privatenames-multi-line.js
+language/statements/class/elements/syntax/valid/grammar-static-private-async-gen-meth-prototype.js
+language/statements/class/elements/syntax/valid/grammar-static-private-async-meth-prototype.js
+language/statements/class/elements/syntax/valid/grammar-static-private-gen-meth-prototype.js
+language/statements/class/elements/syntax/valid/grammar-static-private-meth-prototype.js
+language/statements/class/elements/ternary-init-err-contains-arguments.js
+language/statements/class/elements/typeof-init-err-contains-arguments.js
+language/statements/class/elements/wrapped-in-sc-computed-names.js
+language/statements/class/elements/wrapped-in-sc-grammar-privatename-identifier-semantics-stringvalue.js
+language/statements/class/elements/wrapped-in-sc-private-field-usage.js
+language/statements/class/elements/wrapped-in-sc-private-method-getter-usage.js
+language/statements/class/elements/wrapped-in-sc-private-method-usage.js
+language/statements/class/elements/wrapped-in-sc-private-names.js
+language/statements/class/elements/wrapped-in-sc-rs-private-getter-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-private-getter.js
+language/statements/class/elements/wrapped-in-sc-rs-private-method-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-private-method.js
+language/statements/class/elements/wrapped-in-sc-rs-private-setter-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-private-setter.js
+language/statements/class/elements/wrapped-in-sc-rs-privatename-identifier-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-privatename-identifier-initializer-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-privatename-identifier-initializer.js
+language/statements/class/elements/wrapped-in-sc-rs-privatename-identifier.js
+language/statements/class/elements/wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
+language/statements/class/elements/wrapped-in-sc-rs-static-async-method-privatename-identifier-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-static-async-method-privatename-identifier.js
+language/statements/class/elements/wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
+language/statements/class/elements/wrapped-in-sc-rs-static-method-privatename-identifier-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-static-method-privatename-identifier.js
+language/statements/class/elements/wrapped-in-sc-rs-static-privatename-identifier-alt-by-classname.js
+language/statements/class/elements/wrapped-in-sc-rs-static-privatename-identifier-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-static-privatename-identifier-by-classname.js
+language/statements/class/elements/wrapped-in-sc-rs-static-privatename-identifier-initializer-alt-by-classname.js
+language/statements/class/elements/wrapped-in-sc-rs-static-privatename-identifier-initializer-alt.js
+language/statements/class/elements/wrapped-in-sc-rs-static-privatename-identifier-initializer.js
+language/statements/class/elements/wrapped-in-sc-rs-static-privatename-identifier.js
+language/statements/class/elements/wrapped-in-sc-static-private-fields.js
+language/statements/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
+language/statements/class/elements/wrapped-in-sc-static-private-methods.js
+language/statements/class/elements/wrapped-in-sc-string-literal-names.js
+language/statements/class/static-classelementname-abrupt-completion.js
+language/statements/const/syntax/with-initializer-if-expression-statement-else-statement.js
+language/statements/const/syntax/with-initializer-if-expression-statement.js
+language/statements/for-await-of/async-func-decl-dstr-array-elem-target-simple-strict.js
+language/statements/for-in/dstr/array-elem-target-simple-strict.js
+language/statements/for-in/dstr/obj-id-simple-strict.js
+language/statements/for-of/dstr/array-elem-target-simple-strict.js
+language/statements/for-of/dstr/obj-id-simple-strict.js
+language/statements/if/if-async-fun-else-async-fun.js
+language/statements/if/if-async-fun-else-stmt.js
+language/statements/if/if-async-fun-no-else.js
+language/statements/if/if-async-gen-else-async-gen.js
+language/statements/if/if-async-gen-else-stmt.js
+language/statements/if/if-async-gen-no-else.js
+language/statements/if/if-cls-else-cls.js
+language/statements/if/if-cls-else-stmt.js
+language/statements/if/if-cls-no-else.js
+language/statements/if/if-const-else-const.js
+language/statements/if/if-const-else-stmt.js
+language/statements/if/if-const-no-else.js
+language/statements/if/if-decl-else-decl-strict.js
+language/statements/if/if-decl-else-stmt-strict.js
+language/statements/if/if-decl-no-else-strict.js
+language/statements/if/if-fun-else-fun-strict.js
+language/statements/if/if-fun-else-stmt-strict.js
+language/statements/if/if-fun-no-else-strict.js
+language/statements/if/if-gen-else-gen.js
+language/statements/if/if-gen-else-stmt.js
+language/statements/if/if-gen-no-else.js
+language/statements/if/if-let-else-let.js
+language/statements/if/if-let-else-stmt.js
+language/statements/if/if-let-no-else.js
+language/statements/if/if-stmt-else-async-fun.js
+language/statements/if/if-stmt-else-async-gen.js
+language/statements/if/if-stmt-else-cls.js
+language/statements/if/if-stmt-else-const.js
+language/statements/if/if-stmt-else-decl-strict.js
+language/statements/if/if-stmt-else-fun-strict.js
+language/statements/if/if-stmt-else-gen.js
+language/statements/if/if-stmt-else-let.js
+language/statements/let/syntax/with-initialisers-in-statement-positions-if-expression-statement-else-statement.js
+language/statements/let/syntax/with-initialisers-in-statement-positions-if-expression-statement.js
+language/statements/let/syntax/without-initialisers-in-statement-positions-if-expression-statement-else-statement.js
+language/statements/let/syntax/without-initialisers-in-statement-positions-if-expression-statement.js
+
+# ES2PANDA_FAIL
+# Async generator is unimplemented feature, these tests can be removed by MR9709
+language/expressions/object/dstr/async-gen-meth-ary-init-iter-get-err.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elem-ary-val-null.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elem-id-init-throws.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elem-id-init-unresolvable.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elem-id-iter-step-err.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elem-id-iter-val-err.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elem-obj-val-null.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elem-obj-val-undef.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-elision-step-err.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-id-elision-next-err.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-id-iter-step-err.js
+language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-id-iter-val-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-init-iter-get-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elem-ary-val-null.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elem-id-init-throws.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elem-id-init-unresolvable.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elem-id-iter-step-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elem-id-iter-val-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elem-obj-val-null.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elem-obj-val-undef.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-elision-step-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-id-elision-next-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-id-iter-step-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-id-iter-val-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-init-null.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-init-undefined.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-id-get-value-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-id-init-throws.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-id-init-unresolvable.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-list-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-prop-ary-value-null.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-prop-eval-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-prop-id-get-value-err.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-prop-id-init-throws.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-prop-id-init-unresolvable.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-prop-obj-value-null.js
+language/expressions/object/dstr/async-gen-meth-dflt-obj-ptrn-prop-obj-value-undef.js
+language/expressions/object/dstr/async-gen-meth-obj-init-null.js
+language/expressions/object/dstr/async-gen-meth-obj-init-undefined.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-id-get-value-err.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-id-init-throws.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-id-init-unresolvable.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-list-err.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-prop-ary-value-null.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-prop-eval-err.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-prop-id-get-value-err.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-prop-id-init-throws.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-prop-id-init-unresolvable.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-prop-obj-value-null.js
+language/expressions/object/dstr/async-gen-meth-obj-ptrn-prop-obj-value-undef.js
+language/expressions/object/method-definition/async-gen-meth-dflt-params-abrupt.js
+
+# RUNTIME_FAIL
+annexB/built-ins/Date/prototype/getYear/B.2.4.js
+annexB/built-ins/Date/prototype/getYear/length.js
+annexB/built-ins/Date/prototype/getYear/name.js
+annexB/built-ins/Date/prototype/getYear/nan.js
+annexB/built-ins/Date/prototype/getYear/return-value.js
+annexB/built-ins/Date/prototype/getYear/this-not-date.js
+annexB/built-ins/Date/prototype/setYear/B.2.5.js
+annexB/built-ins/Date/prototype/setYear/length.js
+annexB/built-ins/Date/prototype/setYear/name.js
+annexB/built-ins/Date/prototype/setYear/this-not-date.js
+annexB/built-ins/Date/prototype/setYear/this-time-nan.js
+annexB/built-ins/Date/prototype/setYear/this-time-valid.js
+annexB/built-ins/Date/prototype/setYear/time-clip.js
+annexB/built-ins/Date/prototype/setYear/year-nan.js
+annexB/built-ins/Date/prototype/setYear/year-number-absolute.js
+annexB/built-ins/Date/prototype/setYear/year-number-relative.js
+annexB/built-ins/Date/prototype/setYear/year-to-number-err.js
+annexB/built-ins/Date/prototype/toGMTString/prop-desc.js
+annexB/built-ins/Date/prototype/toGMTString/value.js
+annexB/built-ins/Function/createdynfn-html-close-comment-body.js
+annexB/built-ins/Function/createdynfn-html-close-comment-params.js
+annexB/built-ins/Function/createdynfn-html-open-comment-body.js
+annexB/built-ins/Function/createdynfn-html-open-comment-params.js
+annexB/built-ins/Function/createdynfn-no-line-terminator-html-close-comment-body.js
+annexB/built-ins/Function/createdynfn-no-line-terminator-html-close-comment-params.js
+annexB/built-ins/Object/prototype/__lookupGetter__/lookup-proto-acsr-w-getter.js
+annexB/built-ins/Object/prototype/__lookupGetter__/lookup-proto-get-err.js
+annexB/built-ins/Object/prototype/__lookupSetter__/lookup-proto-acsr-w-setter.js
+annexB/built-ins/Object/prototype/__lookupSetter__/lookup-proto-get-err.js
+annexB/built-ins/RegExp/RegExp-control-escape-russian-letter.js
+annexB/built-ins/RegExp/RegExp-decimal-escape-not-capturing.js
+annexB/built-ins/RegExp/RegExp-invalid-control-escape-character-class.js
+annexB/built-ins/RegExp/RegExp-leading-escape-BMP.js
+annexB/built-ins/RegExp/RegExp-leading-escape.js
+annexB/built-ins/RegExp/RegExp-trailing-escape-BMP.js
+annexB/built-ins/RegExp/RegExp-trailing-escape.js
+annexB/built-ins/RegExp/match-indices/indices-groups-object.js
+annexB/built-ins/RegExp/named-groups/groups-object.js
+annexB/built-ins/RegExp/named-groups/non-unicode-malformed.js
+annexB/built-ins/RegExp/prototype/Symbol.split/Symbol.match-getter-recompiles-source.js
+annexB/built-ins/RegExp/prototype/Symbol.split/toint32-limit-recompiles-source.js
+annexB/built-ins/RegExp/prototype/compile/B.RegExp.prototype.compile.js
+annexB/built-ins/RegExp/prototype/compile/flags-string-invalid.js
+annexB/built-ins/RegExp/prototype/compile/flags-to-string-err.js
+annexB/built-ins/RegExp/prototype/compile/flags-to-string.js
+annexB/built-ins/RegExp/prototype/compile/flags-undefined.js
+annexB/built-ins/RegExp/prototype/compile/length.js
+annexB/built-ins/RegExp/prototype/compile/name.js
+annexB/built-ins/RegExp/prototype/compile/pattern-regexp-distinct.js
+annexB/built-ins/RegExp/prototype/compile/pattern-regexp-flags-defined.js
+annexB/built-ins/RegExp/prototype/compile/pattern-regexp-immutable-lastindex.js
+annexB/built-ins/RegExp/prototype/compile/pattern-regexp-props.js
+annexB/built-ins/RegExp/prototype/compile/pattern-regexp-same.js
+annexB/built-ins/RegExp/prototype/compile/pattern-string-invalid-u.js
+annexB/built-ins/RegExp/prototype/compile/pattern-string-invalid.js
+annexB/built-ins/RegExp/prototype/compile/pattern-string-u.js
+annexB/built-ins/RegExp/prototype/compile/pattern-string.js
+annexB/built-ins/RegExp/prototype/compile/pattern-to-string-err.js
+annexB/built-ins/RegExp/prototype/compile/pattern-undefined.js
+annexB/built-ins/RegExp/prototype/compile/this-not-object.js
+annexB/built-ins/RegExp/prototype/compile/this-obj-not-regexp.js
+annexB/built-ins/RegExp/prototype/flags/order-after-compile.js
+annexB/built-ins/String/prototype/anchor/B.2.3.2.js
+annexB/built-ins/String/prototype/anchor/attr-tostring-err.js
+annexB/built-ins/String/prototype/anchor/length.js
+annexB/built-ins/String/prototype/anchor/name.js
+annexB/built-ins/String/prototype/anchor/prop-desc.js
+annexB/built-ins/String/prototype/anchor/this-val-tostring-err.js
+annexB/built-ins/String/prototype/big/B.2.3.3.js
+annexB/built-ins/String/prototype/big/length.js
+annexB/built-ins/String/prototype/big/name.js
+annexB/built-ins/String/prototype/big/prop-desc.js
+annexB/built-ins/String/prototype/big/this-val-tostring-err.js
+annexB/built-ins/String/prototype/blink/B.2.3.4.js
+annexB/built-ins/String/prototype/blink/length.js
+annexB/built-ins/String/prototype/blink/name.js
+annexB/built-ins/String/prototype/blink/prop-desc.js
+annexB/built-ins/String/prototype/blink/this-val-tostring-err.js
+annexB/built-ins/String/prototype/bold/B.2.3.5.js
+annexB/built-ins/String/prototype/bold/length.js
+annexB/built-ins/String/prototype/bold/name.js
+annexB/built-ins/String/prototype/bold/prop-desc.js
+annexB/built-ins/String/prototype/bold/this-val-tostring-err.js
+annexB/built-ins/String/prototype/fixed/B.2.3.6.js
+annexB/built-ins/String/prototype/fixed/length.js
+annexB/built-ins/String/prototype/fixed/name.js
+annexB/built-ins/String/prototype/fixed/prop-desc.js
+annexB/built-ins/String/prototype/fixed/this-val-tostring-err.js
+annexB/built-ins/String/prototype/fontcolor/B.2.3.7.js
+annexB/built-ins/String/prototype/fontcolor/attr-tostring-err.js
+annexB/built-ins/String/prototype/fontcolor/length.js
+annexB/built-ins/String/prototype/fontcolor/name.js
+annexB/built-ins/String/prototype/fontcolor/prop-desc.js
+annexB/built-ins/String/prototype/fontcolor/this-val-tostring-err.js
+annexB/built-ins/String/prototype/fontsize/B.2.3.8.js
+annexB/built-ins/String/prototype/fontsize/attr-tostring-err.js
+annexB/built-ins/String/prototype/fontsize/length.js
+annexB/built-ins/String/prototype/fontsize/name.js
+annexB/built-ins/String/prototype/fontsize/prop-desc.js
+annexB/built-ins/String/prototype/fontsize/this-val-tostring-err.js
+annexB/built-ins/String/prototype/italics/B.2.3.9.js
+annexB/built-ins/String/prototype/italics/length.js
+annexB/built-ins/String/prototype/italics/name.js
+annexB/built-ins/String/prototype/italics/prop-desc.js
+annexB/built-ins/String/prototype/italics/this-val-tostring-err.js
+annexB/built-ins/String/prototype/link/B.2.3.10.js
+annexB/built-ins/String/prototype/link/attr-tostring-err.js
+annexB/built-ins/String/prototype/link/length.js
+annexB/built-ins/String/prototype/link/name.js
+annexB/built-ins/String/prototype/link/prop-desc.js
+annexB/built-ins/String/prototype/link/this-val-tostring-err.js
+annexB/built-ins/String/prototype/match/custom-matcher-emulates-undefined.js
+annexB/built-ins/String/prototype/matchAll/custom-matcher-emulates-undefined.js
+annexB/built-ins/String/prototype/replace/custom-replacer-emulates-undefined.js
+annexB/built-ins/String/prototype/replaceAll/custom-replacer-emulates-undefined.js
+annexB/built-ins/String/prototype/search/custom-searcher-emulates-undefined.js
+annexB/built-ins/String/prototype/small/B.2.3.11.js
+annexB/built-ins/String/prototype/small/length.js
+annexB/built-ins/String/prototype/small/name.js
+annexB/built-ins/String/prototype/small/prop-desc.js
+annexB/built-ins/String/prototype/small/this-val-tostring-err.js
+annexB/built-ins/String/prototype/split/custom-splitter-emulates-undefined.js
+annexB/built-ins/String/prototype/strike/B.2.3.12.js
+annexB/built-ins/String/prototype/strike/length.js
+annexB/built-ins/String/prototype/strike/name.js
+annexB/built-ins/String/prototype/strike/prop-desc.js
+annexB/built-ins/String/prototype/strike/this-val-tostring-err.js
+annexB/built-ins/String/prototype/sub/B.2.3.13.js
+annexB/built-ins/String/prototype/sub/length.js
+annexB/built-ins/String/prototype/sub/name.js
+annexB/built-ins/String/prototype/sub/prop-desc.js
+annexB/built-ins/String/prototype/sub/this-val-tostring-err.js
+annexB/built-ins/String/prototype/sup/B.2.3.14.js
+annexB/built-ins/String/prototype/sup/length.js
+annexB/built-ins/String/prototype/sup/name.js
+annexB/built-ins/String/prototype/sup/prop-desc.js
+annexB/built-ins/String/prototype/sup/this-val-tostring-err.js
+annexB/built-ins/escape/empty-string.js
+annexB/built-ins/escape/escape-above-astral.js
+annexB/built-ins/escape/escape-above.js
+annexB/built-ins/escape/escape-below.js
+annexB/built-ins/escape/length.js
+annexB/built-ins/escape/name.js
+annexB/built-ins/escape/prop-desc.js
+annexB/built-ins/escape/to-string-err-symbol.js
+annexB/built-ins/escape/to-string-err.js
+annexB/built-ins/escape/to-string-observe.js
+annexB/built-ins/escape/unmodified.js
+annexB/built-ins/unescape/empty-string.js
+annexB/built-ins/unescape/four-ignore-bad-u.js
+annexB/built-ins/unescape/four-ignore-end-str.js
+annexB/built-ins/unescape/four-ignore-non-hex.js
+annexB/built-ins/unescape/four.js
+annexB/built-ins/unescape/length.js
+annexB/built-ins/unescape/name.js
+annexB/built-ins/unescape/prop-desc.js
+annexB/built-ins/unescape/to-string-err-symbol.js
+annexB/built-ins/unescape/to-string-err.js
+annexB/built-ins/unescape/to-string-observe.js
+annexB/built-ins/unescape/two-ignore-end-str.js
+annexB/built-ins/unescape/two-ignore-non-hex.js
+annexB/built-ins/unescape/two.js
+annexB/language/literals/regexp/identity-escape.js
+annexB/language/literals/regexp/legacy-octal-escape.js
+annexB/language/literals/regexp/non-empty-class-ranges-no-dash.js
+annexB/language/literals/regexp/non-empty-class-ranges.js
+annexB/language/literals/regexp/quantifiable-assertion-followed-by.js
+annexB/language/literals/regexp/quantifiable-assertion-not-followed-by.js
+annexB/language/statements/class/subclass/superclass-emulates-undefined.js
+built-ins/Array/from/proto-from-ctor-realm.js
+built-ins/Array/of/proto-from-ctor-realm.js
+built-ins/Array/proto-from-ctor-realm-one.js
+built-ins/Array/proto-from-ctor-realm-two.js
+built-ins/Array/proto-from-ctor-realm-zero.js
+built-ins/Array/prototype/flat/proxy-access-count.js
+built-ins/Array/prototype/flatMap/proxy-access-count.js
+built-ins/ArrayBuffer/proto-from-ctor-realm.js
+built-ins/ArrayBuffer/prototype/byteLength/detached-buffer.js
+built-ins/ArrayBuffer/prototype/byteLength/this-is-sharedarraybuffer.js
+built-ins/ArrayBuffer/prototype/slice/this-is-sharedarraybuffer.js
+built-ins/ArrayIteratorPrototype/next/detach-typedarray-in-progress.js
+built-ins/AsyncFunction/AsyncFunction-construct.js
+built-ins/AsyncFunction/AsyncFunction-is-subclass.js
+built-ins/AsyncFunction/AsyncFunction-name.js
+built-ins/AsyncFunction/AsyncFunctionPrototype-prototype.js
+built-ins/AsyncFunction/AsyncFunctionPrototype-to-string.js
+built-ins/AsyncFunction/instance-has-name.js
+built-ins/AsyncFunction/instance-length.js
+built-ins/AsyncFunction/proto-from-ctor-realm.js
+built-ins/AsyncGeneratorFunction/has-instance.js
+built-ins/AsyncGeneratorFunction/instance-await-expr-in-param.js
+built-ins/AsyncGeneratorFunction/instance-construct-throws.js
+built-ins/AsyncGeneratorFunction/instance-length.js
+built-ins/AsyncGeneratorFunction/instance-name.js
+built-ins/AsyncGeneratorFunction/instance-prototype.js
+built-ins/AsyncGeneratorFunction/instance-yield-expr-in-param.js
+built-ins/AsyncGeneratorFunction/invoked-as-constructor-no-arguments.js
+built-ins/AsyncGeneratorFunction/invoked-as-function-multiple-arguments.js
+built-ins/AsyncGeneratorFunction/invoked-as-function-no-arguments.js
+built-ins/AsyncGeneratorFunction/invoked-as-function-single-argument.js
+built-ins/AsyncGeneratorFunction/proto-from-ctor-realm-prototype.js
+built-ins/AsyncGeneratorFunction/proto-from-ctor-realm.js
+built-ins/AsyncGeneratorPrototype/constructor.js
+built-ins/Atomics/Symbol.toStringTag.js
+built-ins/Atomics/add/bad-range.js
+built-ins/Atomics/add/descriptor.js
+built-ins/Atomics/add/expected-return-value.js
+built-ins/Atomics/add/good-views.js
+built-ins/Atomics/add/length.js
+built-ins/Atomics/add/name.js
+built-ins/Atomics/add/non-shared-bufferdata.js
+built-ins/Atomics/add/non-shared-int-views-throws.js
+built-ins/Atomics/add/non-views.js
+built-ins/Atomics/add/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/add/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/and/bad-range.js
+built-ins/Atomics/and/descriptor.js
+built-ins/Atomics/and/expected-return-value.js
+built-ins/Atomics/and/good-views.js
+built-ins/Atomics/and/length.js
+built-ins/Atomics/and/name.js
+built-ins/Atomics/and/non-shared-bufferdata.js
+built-ins/Atomics/and/non-shared-int-views-throws.js
+built-ins/Atomics/and/non-views.js
+built-ins/Atomics/and/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/and/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/compareExchange/bad-range.js
+built-ins/Atomics/compareExchange/descriptor.js
+built-ins/Atomics/compareExchange/expected-return-value.js
+built-ins/Atomics/compareExchange/good-views.js
+built-ins/Atomics/compareExchange/length.js
+built-ins/Atomics/compareExchange/name.js
+built-ins/Atomics/compareExchange/non-shared-bufferdata.js
+built-ins/Atomics/compareExchange/non-shared-int-views-throws.js
+built-ins/Atomics/compareExchange/non-views.js
+built-ins/Atomics/compareExchange/validate-arraytype-before-expectedValue-coercion.js
+built-ins/Atomics/compareExchange/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/compareExchange/validate-arraytype-before-replacementValue-coercion.js
+built-ins/Atomics/exchange/bad-range.js
+built-ins/Atomics/exchange/descriptor.js
+built-ins/Atomics/exchange/expected-return-value.js
+built-ins/Atomics/exchange/good-views.js
+built-ins/Atomics/exchange/length.js
+built-ins/Atomics/exchange/name.js
+built-ins/Atomics/exchange/non-shared-bufferdata.js
+built-ins/Atomics/exchange/non-shared-int-views-throws.js
+built-ins/Atomics/exchange/non-views.js
+built-ins/Atomics/exchange/nonshared-int-views.js
+built-ins/Atomics/exchange/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/exchange/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/isLockFree/bigint/expected-return-value.js
+built-ins/Atomics/isLockFree/corner-cases.js
+built-ins/Atomics/isLockFree/descriptor.js
+built-ins/Atomics/isLockFree/expected-return-value.js
+built-ins/Atomics/isLockFree/length.js
+built-ins/Atomics/isLockFree/name.js
+built-ins/Atomics/load/bad-range.js
+built-ins/Atomics/load/bigint/bad-range.js
+built-ins/Atomics/load/descriptor.js
+built-ins/Atomics/load/expected-return-value.js
+built-ins/Atomics/load/good-views.js
+built-ins/Atomics/load/length.js
+built-ins/Atomics/load/name.js
+built-ins/Atomics/load/non-shared-bufferdata.js
+built-ins/Atomics/load/non-shared-int-views-throws.js
+built-ins/Atomics/load/non-views.js
+built-ins/Atomics/load/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/notify/bad-range.js
+built-ins/Atomics/notify/bigint/bad-range.js
+built-ins/Atomics/notify/bigint/non-bigint64-typedarray-throws.js
+built-ins/Atomics/notify/bigint/non-shared-bufferdata-count-evaluation-throws.js
+built-ins/Atomics/notify/bigint/non-shared-bufferdata-index-evaluation-throws.js
+built-ins/Atomics/notify/bigint/non-shared-bufferdata-non-shared-int-views-throws.js
+built-ins/Atomics/notify/bigint/non-shared-bufferdata-returns-0.js
+built-ins/Atomics/notify/bigint/null-bufferdata-throws.js
+built-ins/Atomics/notify/count-boundary-cases.js
+built-ins/Atomics/notify/count-defaults-to-infinity-missing.js
+built-ins/Atomics/notify/count-defaults-to-infinity-undefined.js
+built-ins/Atomics/notify/count-from-nans.js
+built-ins/Atomics/notify/count-symbol-throws.js
+built-ins/Atomics/notify/count-tointeger-throws-then-wake-throws.js
+built-ins/Atomics/notify/descriptor.js
+built-ins/Atomics/notify/length.js
+built-ins/Atomics/notify/name.js
+built-ins/Atomics/notify/negative-count.js
+built-ins/Atomics/notify/negative-index-throws.js
+built-ins/Atomics/notify/non-int32-typedarray-throws.js
+built-ins/Atomics/notify/non-shared-bufferdata-count-evaluation-throws.js
+built-ins/Atomics/notify/non-shared-bufferdata-index-evaluation-throws.js
+built-ins/Atomics/notify/non-shared-bufferdata-non-shared-int-views-throws.js
+built-ins/Atomics/notify/non-shared-bufferdata-returns-0.js
+built-ins/Atomics/notify/non-shared-int-views.js
+built-ins/Atomics/notify/non-views.js
+built-ins/Atomics/notify/not-a-typedarray-throws.js
+built-ins/Atomics/notify/not-an-object-throws.js
+built-ins/Atomics/notify/notify-all-on-loc.js
+built-ins/Atomics/notify/notify-all.js
+built-ins/Atomics/notify/notify-in-order-one-time.js
+built-ins/Atomics/notify/notify-in-order.js
+built-ins/Atomics/notify/notify-nan.js
+built-ins/Atomics/notify/notify-one.js
+built-ins/Atomics/notify/notify-renotify-noop.js
+built-ins/Atomics/notify/notify-two.js
+built-ins/Atomics/notify/notify-with-no-agents-waiting.js
+built-ins/Atomics/notify/notify-with-no-matching-agents-waiting.js
+built-ins/Atomics/notify/notify-zero.js
+built-ins/Atomics/notify/null-bufferdata-throws.js
+built-ins/Atomics/notify/out-of-range-index-throws.js
+built-ins/Atomics/notify/symbol-for-index-throws.js
+built-ins/Atomics/notify/undefined-index-defaults-to-zero.js
+built-ins/Atomics/notify/validate-arraytype-before-count-coercion.js
+built-ins/Atomics/notify/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/or/bad-range.js
+built-ins/Atomics/or/descriptor.js
+built-ins/Atomics/or/expected-return-value.js
+built-ins/Atomics/or/good-views.js
+built-ins/Atomics/or/length.js
+built-ins/Atomics/or/name.js
+built-ins/Atomics/or/non-shared-bufferdata.js
+built-ins/Atomics/or/non-shared-int-views-throws.js
+built-ins/Atomics/or/non-views.js
+built-ins/Atomics/or/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/or/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/prop-desc.js
+built-ins/Atomics/proto.js
+built-ins/Atomics/store/bad-range.js
+built-ins/Atomics/store/descriptor.js
+built-ins/Atomics/store/expected-return-value-negative-zero.js
+built-ins/Atomics/store/expected-return-value.js
+built-ins/Atomics/store/good-views.js
+built-ins/Atomics/store/length.js
+built-ins/Atomics/store/name.js
+built-ins/Atomics/store/non-shared-bufferdata.js
+built-ins/Atomics/store/non-shared-int-views-throws.js
+built-ins/Atomics/store/non-views.js
+built-ins/Atomics/store/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/store/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/sub/bad-range.js
+built-ins/Atomics/sub/descriptor.js
+built-ins/Atomics/sub/expected-return-value.js
+built-ins/Atomics/sub/good-views.js
+built-ins/Atomics/sub/length.js
+built-ins/Atomics/sub/name.js
+built-ins/Atomics/sub/non-shared-bufferdata.js
+built-ins/Atomics/sub/non-shared-int-views-throws.js
+built-ins/Atomics/sub/non-views.js
+built-ins/Atomics/sub/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/sub/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/wait/bad-range.js
+built-ins/Atomics/wait/bigint/negative-index-throws.js
+built-ins/Atomics/wait/bigint/null-bufferdata-throws.js
+built-ins/Atomics/wait/bigint/out-of-range-index-throws.js
+built-ins/Atomics/wait/bigint/waiterlist-block-indexedposition-wake.js
+built-ins/Atomics/wait/cannot-suspend-throws.js
+built-ins/Atomics/wait/descriptor.js
+built-ins/Atomics/wait/false-for-timeout-agent.js
+built-ins/Atomics/wait/false-for-timeout.js
+built-ins/Atomics/wait/good-views.js
+built-ins/Atomics/wait/length.js
+built-ins/Atomics/wait/name.js
+built-ins/Atomics/wait/nan-for-timeout.js
+built-ins/Atomics/wait/negative-index-throws.js
+built-ins/Atomics/wait/negative-timeout-agent.js
+built-ins/Atomics/wait/negative-timeout.js
+built-ins/Atomics/wait/no-spurious-wakeup-no-operation.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-add.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-and.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-compareExchange.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-exchange.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-or.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-store.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-sub.js
+built-ins/Atomics/wait/no-spurious-wakeup-on-xor.js
+built-ins/Atomics/wait/non-int32-typedarray-throws.js
+built-ins/Atomics/wait/non-shared-bufferdata-throws.js
+built-ins/Atomics/wait/not-a-typedarray-throws.js
+built-ins/Atomics/wait/not-an-object-throws.js
+built-ins/Atomics/wait/null-bufferdata-throws.js
+built-ins/Atomics/wait/null-for-timeout-agent.js
+built-ins/Atomics/wait/null-for-timeout.js
+built-ins/Atomics/wait/object-for-timeout-agent.js
+built-ins/Atomics/wait/object-for-timeout.js
+built-ins/Atomics/wait/out-of-range-index-throws.js
+built-ins/Atomics/wait/poisoned-object-for-timeout-throws-agent.js
+built-ins/Atomics/wait/poisoned-object-for-timeout-throws.js
+built-ins/Atomics/wait/symbol-for-index-throws-agent.js
+built-ins/Atomics/wait/symbol-for-index-throws.js
+built-ins/Atomics/wait/symbol-for-timeout-throws-agent.js
+built-ins/Atomics/wait/symbol-for-timeout-throws.js
+built-ins/Atomics/wait/symbol-for-value-throws-agent.js
+built-ins/Atomics/wait/symbol-for-value-throws.js
+built-ins/Atomics/wait/true-for-timeout-agent.js
+built-ins/Atomics/wait/true-for-timeout.js
+built-ins/Atomics/wait/undefined-for-timeout.js
+built-ins/Atomics/wait/undefined-index-defaults-to-zero.js
+built-ins/Atomics/wait/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/wait/validate-arraytype-before-timeout-coercion.js
+built-ins/Atomics/wait/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/wait/value-not-equal.js
+built-ins/Atomics/wait/wait-index-value-not-equal.js
+built-ins/Atomics/wait/waiterlist-block-indexedposition-wake.js
+built-ins/Atomics/wait/waiterlist-order-of-operations-is-fifo.js
+built-ins/Atomics/wait/was-woken-before-timeout.js
+built-ins/Atomics/waitAsync/bad-range.js
+built-ins/Atomics/waitAsync/bigint/good-views.js
+built-ins/Atomics/waitAsync/bigint/negative-index-throws.js
+built-ins/Atomics/waitAsync/bigint/non-bigint64-typedarray-throws.js
+built-ins/Atomics/waitAsync/bigint/not-an-object-throws.js
+built-ins/Atomics/waitAsync/bigint/null-bufferdata-throws.js
+built-ins/Atomics/waitAsync/bigint/out-of-range-index-throws.js
+built-ins/Atomics/waitAsync/bigint/symbol-for-index-throws.js
+built-ins/Atomics/waitAsync/bigint/symbol-for-value-throws.js
+built-ins/Atomics/waitAsync/bigint/undefined-for-timeout-agent.js
+built-ins/Atomics/waitAsync/bigint/undefined-index-defaults-to-zero-agent.js
+built-ins/Atomics/waitAsync/bigint/waiterlist-block-indexedposition-wake.js
+built-ins/Atomics/waitAsync/descriptor.js
+built-ins/Atomics/waitAsync/false-for-timeout-agent.js
+built-ins/Atomics/waitAsync/false-for-timeout.js
+built-ins/Atomics/waitAsync/good-views.js
+built-ins/Atomics/waitAsync/is-function.js
+built-ins/Atomics/waitAsync/length.js
+built-ins/Atomics/waitAsync/name.js
+built-ins/Atomics/waitAsync/nan-for-timeout-agent.js
+built-ins/Atomics/waitAsync/negative-index-throws.js
+built-ins/Atomics/waitAsync/negative-timeout-agent.js
+built-ins/Atomics/waitAsync/negative-timeout.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-no-operation.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-add.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-and.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-compareExchange.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-exchange.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-or.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-store.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-sub.js
+built-ins/Atomics/waitAsync/no-spurious-wakeup-on-xor.js
+built-ins/Atomics/waitAsync/non-int32-typedarray-throws.js
+built-ins/Atomics/waitAsync/non-shared-bufferdata-throws.js
+built-ins/Atomics/waitAsync/not-a-typedarray-throws.js
+built-ins/Atomics/waitAsync/not-an-object-throws.js
+built-ins/Atomics/waitAsync/null-bufferdata-throws.js
+built-ins/Atomics/waitAsync/null-for-timeout-agent.js
+built-ins/Atomics/waitAsync/null-for-timeout.js
+built-ins/Atomics/waitAsync/object-for-timeout-agent.js
+built-ins/Atomics/waitAsync/object-for-timeout.js
+built-ins/Atomics/waitAsync/out-of-range-index-throws.js
+built-ins/Atomics/waitAsync/poisoned-object-for-timeout-throws-agent.js
+built-ins/Atomics/waitAsync/poisoned-object-for-timeout-throws.js
+built-ins/Atomics/waitAsync/returns-result-object-value-is-promise-resolves-to-ok.js
+built-ins/Atomics/waitAsync/returns-result-object-value-is-promise-resolves-to-timed-out.js
+built-ins/Atomics/waitAsync/returns-result-object-value-is-string-not-equal.js
+built-ins/Atomics/waitAsync/returns-result-object-value-is-string-timed-out.js
+built-ins/Atomics/waitAsync/symbol-for-index-throws-agent.js
+built-ins/Atomics/waitAsync/symbol-for-index-throws.js
+built-ins/Atomics/waitAsync/symbol-for-timeout-throws-agent.js
+built-ins/Atomics/waitAsync/symbol-for-timeout-throws.js
+built-ins/Atomics/waitAsync/symbol-for-value-throws-agent.js
+built-ins/Atomics/waitAsync/symbol-for-value-throws.js
+built-ins/Atomics/waitAsync/true-for-timeout-agent.js
+built-ins/Atomics/waitAsync/true-for-timeout.js
+built-ins/Atomics/waitAsync/undefined-for-timeout-agent.js
+built-ins/Atomics/waitAsync/undefined-for-timeout.js
+built-ins/Atomics/waitAsync/undefined-index-defaults-to-zero-agent.js
+built-ins/Atomics/waitAsync/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/waitAsync/validate-arraytype-before-timeout-coercion.js
+built-ins/Atomics/waitAsync/validate-arraytype-before-value-coercion.js
+built-ins/Atomics/waitAsync/value-not-equal-agent.js
+built-ins/Atomics/waitAsync/value-not-equal.js
+built-ins/Atomics/waitAsync/waiterlist-block-indexedposition-wake.js
+built-ins/Atomics/waitAsync/was-woken-before-timeout.js
+built-ins/Atomics/xor/bad-range.js
+built-ins/Atomics/xor/bigint/bad-range.js
+built-ins/Atomics/xor/descriptor.js
+built-ins/Atomics/xor/expected-return-value.js
+built-ins/Atomics/xor/good-views.js
+built-ins/Atomics/xor/length.js
+built-ins/Atomics/xor/name.js
+built-ins/Atomics/xor/non-shared-bufferdata.js
+built-ins/Atomics/xor/non-shared-int-views-throws.js
+built-ins/Atomics/xor/non-views.js
+built-ins/Atomics/xor/validate-arraytype-before-index-coercion.js
+built-ins/Atomics/xor/validate-arraytype-before-value-coercion.js
+built-ins/BigInt/asIntN/asIntN.js
+built-ins/BigInt/asIntN/bigint-tobigint-errors.js
+built-ins/BigInt/asIntN/length.js
+built-ins/BigInt/asIntN/name.js
+built-ins/BigInt/asUintN/asUintN.js
+built-ins/BigInt/asUintN/bigint-tobigint-errors.js
+built-ins/BigInt/asUintN/length.js
+built-ins/BigInt/asUintN/name.js
+built-ins/BigInt/constructor-from-string-syntax-errors.js
+built-ins/BigInt/infinity-throws-rangeerror.js
+built-ins/BigInt/length.js
+built-ins/BigInt/name.js
+built-ins/BigInt/nan-throws-rangeerror.js
+built-ins/BigInt/negative-infinity-throws.rangeerror.js
+built-ins/BigInt/new-target-throws.js
+built-ins/BigInt/non-integer-rangeerror.js
+built-ins/BigInt/parseInt/nonexistent.js
+built-ins/BigInt/prop-desc.js
+built-ins/BigInt/proto.js
+built-ins/BigInt/prototype/Symbol.toStringTag.js
+built-ins/BigInt/prototype/constructor.js
+built-ins/BigInt/prototype/prop-desc.js
+built-ins/BigInt/prototype/proto.js
+built-ins/BigInt/prototype/toString/length.js
+built-ins/BigInt/prototype/toString/name.js
+built-ins/BigInt/prototype/toString/prop-desc.js
+built-ins/BigInt/prototype/toString/prototype-call.js
+built-ins/BigInt/prototype/valueOf/length.js
+built-ins/BigInt/prototype/valueOf/name.js
+built-ins/BigInt/prototype/valueOf/prop-desc.js
+built-ins/BigInt/prototype/valueOf/this-value-invalid-object-throws.js
+built-ins/BigInt/prototype/valueOf/this-value-invalid-primitive-throws.js
+built-ins/BigInt/tostring-throws.js
+built-ins/BigInt/valueof-throws.js
+built-ins/Boolean/S9.2_A1_T1.js
+built-ins/Boolean/proto-from-ctor-realm.js
+built-ins/DataView/buffer-does-not-have-arraybuffer-data-throws-sab.js
+built-ins/DataView/buffer-reference-sab.js
+built-ins/DataView/byteoffset-is-negative-throws-sab.js
+built-ins/DataView/custom-proto-access-throws-sab.js
+built-ins/DataView/custom-proto-if-not-object-fallbacks-to-default-prototype-sab.js
+built-ins/DataView/custom-proto-if-object-is-used-sab.js
+built-ins/DataView/defined-bytelength-and-byteoffset-sab.js
+built-ins/DataView/defined-byteoffset-sab.js
+built-ins/DataView/defined-byteoffset-undefined-bytelength-sab.js
+built-ins/DataView/detached-buffer.js
+built-ins/DataView/excessive-bytelength-throws-sab.js
+built-ins/DataView/excessive-byteoffset-throws-sab.js
+built-ins/DataView/instance-extensibility-sab.js
+built-ins/DataView/negative-bytelength-throws-sab.js
+built-ins/DataView/negative-byteoffset-throws-sab.js
+built-ins/DataView/newtarget-undefined-throws-sab.js
+built-ins/DataView/proto-from-ctor-realm-sab.js
+built-ins/DataView/proto-from-ctor-realm.js
+built-ins/DataView/prototype/buffer/detached-buffer.js
+built-ins/DataView/prototype/buffer/return-buffer-sab.js
+built-ins/DataView/prototype/buffer/this-has-no-dataview-internal-sab.js
+built-ins/DataView/prototype/byteLength/detached-buffer.js
+built-ins/DataView/prototype/byteLength/return-bytelength-sab.js
+built-ins/DataView/prototype/byteLength/this-has-no-dataview-internal-sab.js
+built-ins/DataView/prototype/byteOffset/detached-buffer.js
+built-ins/DataView/prototype/byteOffset/return-byteoffset-sab.js
+built-ins/DataView/prototype/byteOffset/this-has-no-dataview-internal-sab.js
+built-ins/DataView/prototype/getBigInt64/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getBigInt64/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getBigInt64/detached-buffer.js
+built-ins/DataView/prototype/getBigInt64/index-is-out-of-range.js
+built-ins/DataView/prototype/getBigInt64/length.js
+built-ins/DataView/prototype/getBigInt64/name.js
+built-ins/DataView/prototype/getBigInt64/negative-byteoffset-throws.js
+built-ins/DataView/prototype/getBigInt64/return-abrupt-from-tonumber-byteoffset.js
+built-ins/DataView/prototype/getBigUint64/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getBigUint64/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getBigUint64/detached-buffer.js
+built-ins/DataView/prototype/getBigUint64/index-is-out-of-range.js
+built-ins/DataView/prototype/getBigUint64/length.js
+built-ins/DataView/prototype/getBigUint64/name.js
+built-ins/DataView/prototype/getBigUint64/negative-byteoffset-throws.js
+built-ins/DataView/prototype/getBigUint64/return-abrupt-from-tonumber-byteoffset.js
+built-ins/DataView/prototype/getFloat32/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getFloat32/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getFloat32/detached-buffer.js
+built-ins/DataView/prototype/getFloat64/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getFloat64/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getFloat64/detached-buffer.js
+built-ins/DataView/prototype/getInt16/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getInt16/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getInt16/detached-buffer.js
+built-ins/DataView/prototype/getInt32/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getInt32/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getInt32/detached-buffer.js
+built-ins/DataView/prototype/getInt32/index-is-out-of-range-sab.js
+built-ins/DataView/prototype/getInt32/negative-byteoffset-throws-sab.js
+built-ins/DataView/prototype/getInt32/return-abrupt-from-tonumber-byteoffset-sab.js
+built-ins/DataView/prototype/getInt32/return-abrupt-from-tonumber-byteoffset-symbol-sab.js
+built-ins/DataView/prototype/getInt32/return-value-clean-arraybuffer-sab.js
+built-ins/DataView/prototype/getInt32/return-values-custom-offset-sab.js
+built-ins/DataView/prototype/getInt32/return-values-sab.js
+built-ins/DataView/prototype/getInt32/this-has-no-dataview-internal-sab.js
+built-ins/DataView/prototype/getInt32/to-boolean-littleendian-sab.js
+built-ins/DataView/prototype/getInt32/toindex-byteoffset-sab.js
+built-ins/DataView/prototype/getInt8/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getInt8/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getInt8/detached-buffer.js
+built-ins/DataView/prototype/getUint16/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getUint16/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getUint16/detached-buffer.js
+built-ins/DataView/prototype/getUint32/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getUint32/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getUint32/detached-buffer.js
+built-ins/DataView/prototype/getUint8/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/getUint8/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/getUint8/detached-buffer.js
+built-ins/DataView/prototype/setBigInt64/detached-buffer-after-bigint-value.js
+built-ins/DataView/prototype/setBigInt64/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setBigInt64/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setBigInt64/index-check-before-value-conversion.js
+built-ins/DataView/prototype/setBigInt64/length.js
+built-ins/DataView/prototype/setBigInt64/name.js
+built-ins/DataView/prototype/setBigInt64/range-check-after-value-conversion.js
+built-ins/DataView/prototype/setBigInt64/return-abrupt-from-tobigint-value.js
+built-ins/DataView/prototype/setBigInt64/set-values-return-undefined.js
+built-ins/DataView/prototype/setFloat32/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setFloat32/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setFloat32/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setFloat32/detached-buffer.js
+built-ins/DataView/prototype/setFloat64/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setFloat64/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setFloat64/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setFloat64/detached-buffer.js
+built-ins/DataView/prototype/setInt16/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setInt16/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setInt16/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setInt16/detached-buffer.js
+built-ins/DataView/prototype/setInt32/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setInt32/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setInt32/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setInt32/detached-buffer.js
+built-ins/DataView/prototype/setInt8/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setInt8/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setInt8/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setInt8/detached-buffer.js
+built-ins/DataView/prototype/setUint16/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setUint16/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setUint16/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setUint16/detached-buffer.js
+built-ins/DataView/prototype/setUint32/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setUint32/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setUint32/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setUint32/detached-buffer.js
+built-ins/DataView/prototype/setUint8/detached-buffer-after-number-value.js
+built-ins/DataView/prototype/setUint8/detached-buffer-after-toindex-byteoffset.js
+built-ins/DataView/prototype/setUint8/detached-buffer-before-outofrange-byteoffset.js
+built-ins/DataView/prototype/setUint8/detached-buffer.js
+built-ins/DataView/return-abrupt-tonumber-bytelength-sab.js
+built-ins/DataView/return-abrupt-tonumber-bytelength-symbol-sab.js
+built-ins/DataView/return-abrupt-tonumber-byteoffset-sab.js
+built-ins/DataView/return-abrupt-tonumber-byteoffset-symbol-sab.js
+built-ins/DataView/return-instance-sab.js
+built-ins/DataView/toindex-bytelength-sab.js
+built-ins/DataView/toindex-byteoffset-sab.js
+built-ins/Date/UTC/year-offset.js
+built-ins/Date/parse/S15.9.4.2_A2_T1.js
+built-ins/Date/proto-from-ctor-realm-one.js
+built-ins/Date/proto-from-ctor-realm-two.js
+built-ins/Date/proto-from-ctor-realm-zero.js
+built-ins/Date/prototype/Symbol.toPrimitive/prop-desc.js
+built-ins/Date/prototype/constructor/S15.9.5.1_A3_T2.js
+built-ins/Date/prototype/setFullYear/this-value-invalid-date.js
+built-ins/Error/S15.11.1.1_A1_T1.js
+built-ins/Error/S15.11.2.1_A1_T1.js
+built-ins/Error/proto-from-ctor-realm.js
+built-ins/FinalizationRegistry/constructor.js
+built-ins/FinalizationRegistry/gc-has-one-chance-to-call-cleanupCallback.js
+built-ins/FinalizationRegistry/instance-extensible.js
+built-ins/FinalizationRegistry/length.js
+built-ins/FinalizationRegistry/name.js
+built-ins/FinalizationRegistry/newtarget-prototype-is-not-object.js
+built-ins/FinalizationRegistry/prop-desc.js
+built-ins/FinalizationRegistry/proto-from-ctor-realm.js
+built-ins/FinalizationRegistry/proto.js
+built-ins/FinalizationRegistry/prototype-from-newtarget-abrupt.js
+built-ins/FinalizationRegistry/prototype-from-newtarget-custom.js
+built-ins/FinalizationRegistry/prototype-from-newtarget.js
+built-ins/FinalizationRegistry/prototype/Symbol.toStringTag.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/callback-not-callable-throws.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-reference.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-unregister.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/custom-this.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/holdings-multiple-values.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/length.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/name.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/prop-desc.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/reentrancy.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined-with-gc.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/this-does-not-have-internal-cells-throws.js
+built-ins/FinalizationRegistry/prototype/cleanupSome/this-not-object-throws.js
+built-ins/FinalizationRegistry/prototype/constructor.js
+built-ins/FinalizationRegistry/prototype/prop-desc.js
+built-ins/FinalizationRegistry/prototype/proto.js
+built-ins/FinalizationRegistry/prototype/register/custom-this.js
+built-ins/FinalizationRegistry/prototype/register/holdings-any-value-type.js
+built-ins/FinalizationRegistry/prototype/register/holdings-same-as-target.js
+built-ins/FinalizationRegistry/prototype/register/length.js
+built-ins/FinalizationRegistry/prototype/register/name.js
+built-ins/FinalizationRegistry/prototype/register/prop-desc.js
+built-ins/FinalizationRegistry/prototype/register/return-undefined-register-itself.js
+built-ins/FinalizationRegistry/prototype/register/return-undefined.js
+built-ins/FinalizationRegistry/prototype/register/target-not-object-throws.js
+built-ins/FinalizationRegistry/prototype/register/this-does-not-have-internal-target-throws.js
+built-ins/FinalizationRegistry/prototype/register/this-not-object-throws.js
+built-ins/FinalizationRegistry/prototype/register/unregisterToken-not-object-or-undefined-throws.js
+built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings-and-target.js
+built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings.js
+built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-target.js
+built-ins/FinalizationRegistry/prototype/unregister/custom-this.js
+built-ins/FinalizationRegistry/prototype/unregister/length.js
+built-ins/FinalizationRegistry/prototype/unregister/name.js
+built-ins/FinalizationRegistry/prototype/unregister/prop-desc.js
+built-ins/FinalizationRegistry/prototype/unregister/this-does-not-have-internal-cells-throws.js
+built-ins/FinalizationRegistry/prototype/unregister/this-not-object-throws.js
+built-ins/FinalizationRegistry/prototype/unregister/unregister-cleaned-up-cell.js
+built-ins/FinalizationRegistry/prototype/unregister/unregister.js
+built-ins/FinalizationRegistry/prototype/unregister/unregisterToken-not-object-throws.js
+built-ins/FinalizationRegistry/returns-new-object-from-constructor.js
+built-ins/FinalizationRegistry/target-not-callable-throws.js
+built-ins/FinalizationRegistry/undefined-newtarget-throws.js
+built-ins/FinalizationRegistry/unnaffected-by-poisoned-cleanupCallback.js
+built-ins/Function/15.3.2.1-11-1.js
+built-ins/Function/15.3.2.1-11-2-s.js
+built-ins/Function/15.3.2.1-11-3.js
+built-ins/Function/15.3.2.1-11-4-s.js
+built-ins/Function/15.3.2.1-11-5.js
+built-ins/Function/15.3.2.1-11-6-s.js
+built-ins/Function/15.3.2.1-11-7-s.js
+built-ins/Function/15.3.2.1-11-8-s.js
+built-ins/Function/15.3.2.1-11-9-s.js
+built-ins/Function/15.3.5.4_2-7gs.js
+built-ins/Function/15.3.5.4_2-9gs.js
+built-ins/Function/S15.3.1_A1_T1.js
+built-ins/Function/S15.3.2.1_A1_T1.js
+built-ins/Function/S15.3.2.1_A1_T10.js
+built-ins/Function/S15.3.2.1_A1_T11.js
+built-ins/Function/S15.3.2.1_A1_T12.js
+built-ins/Function/S15.3.2.1_A1_T13.js
+built-ins/Function/S15.3.2.1_A1_T2.js
+built-ins/Function/S15.3.2.1_A1_T3.js
+built-ins/Function/S15.3.2.1_A1_T4.js
+built-ins/Function/S15.3.2.1_A1_T5.js
+built-ins/Function/S15.3.2.1_A1_T6.js
+built-ins/Function/S15.3.2.1_A1_T7.js
+built-ins/Function/S15.3.2.1_A1_T8.js
+built-ins/Function/S15.3.2.1_A1_T9.js
+built-ins/Function/S15.3.2.1_A2_T1.js
+built-ins/Function/S15.3.2.1_A2_T2.js
+built-ins/Function/S15.3.2.1_A2_T3.js
+built-ins/Function/S15.3.2.1_A2_T4.js
+built-ins/Function/S15.3.2.1_A2_T5.js
+built-ins/Function/S15.3.2.1_A2_T6.js
+built-ins/Function/S15.3.2.1_A3_T1.js
+built-ins/Function/S15.3.2.1_A3_T10.js
+built-ins/Function/S15.3.2.1_A3_T11.js
+built-ins/Function/S15.3.2.1_A3_T12.js
+built-ins/Function/S15.3.2.1_A3_T13.js
+built-ins/Function/S15.3.2.1_A3_T14.js
+built-ins/Function/S15.3.2.1_A3_T15.js
+built-ins/Function/S15.3.2.1_A3_T2.js
+built-ins/Function/S15.3.2.1_A3_T3.js
+built-ins/Function/S15.3.2.1_A3_T4.js
+built-ins/Function/S15.3.2.1_A3_T5.js
+built-ins/Function/S15.3.2.1_A3_T6.js
+built-ins/Function/S15.3.2.1_A3_T7.js
+built-ins/Function/S15.3.2.1_A3_T8.js
+built-ins/Function/S15.3.2.1_A3_T9.js
+built-ins/Function/S15.3.5_A2_T1.js
+built-ins/Function/S15.3.5_A2_T2.js
+built-ins/Function/S15.3.5_A3_T1.js
+built-ins/Function/S15.3.5_A3_T2.js
+built-ins/Function/S15.3_A2_T1.js
+built-ins/Function/S15.3_A2_T2.js
+built-ins/Function/S15.3_A3_T1.js
+built-ins/Function/S15.3_A3_T2.js
+built-ins/Function/S15.3_A3_T3.js
+built-ins/Function/S15.3_A3_T4.js
+built-ins/Function/S15.3_A3_T5.js
+built-ins/Function/S15.3_A3_T6.js
+built-ins/Function/StrictFunction_restricted-properties.js
+built-ins/Function/call-bind-this-realm-undef.js
+built-ins/Function/call-bind-this-realm-value.js
+built-ins/Function/instance-name.js
+built-ins/Function/internals/Call/class-ctor-realm.js
+built-ins/Function/internals/Construct/base-ctor-revoked-proxy-realm.js
+built-ins/Function/internals/Construct/base-ctor-revoked-proxy.js
+built-ins/Function/internals/Construct/derived-return-val-realm.js
+built-ins/Function/internals/Construct/derived-this-uninitialized-realm.js
+built-ins/Function/length/S15.3.5.1_A1_T1.js
+built-ins/Function/length/S15.3.5.1_A1_T2.js
+built-ins/Function/length/S15.3.5.1_A1_T3.js
+built-ins/Function/length/S15.3.5.1_A2_T1.js
+built-ins/Function/length/S15.3.5.1_A2_T2.js
+built-ins/Function/length/S15.3.5.1_A2_T3.js
+built-ins/Function/length/S15.3.5.1_A3_T1.js
+built-ins/Function/length/S15.3.5.1_A3_T2.js
+built-ins/Function/length/S15.3.5.1_A3_T3.js
+built-ins/Function/length/S15.3.5.1_A4_T1.js
+built-ins/Function/length/S15.3.5.1_A4_T2.js
+built-ins/Function/length/S15.3.5.1_A4_T3.js
+built-ins/Function/private-identifiers-not-empty.js
+built-ins/Function/proto-from-ctor-realm-prototype.js
+built-ins/Function/proto-from-ctor-realm.js
+built-ins/Function/prototype/S15.3.5.2_A1_T1.js
+built-ins/Function/prototype/S15.3.5.2_A1_T2.js
+built-ins/Function/prototype/apply/S15.3.4.3_A3_T1.js
+built-ins/Function/prototype/apply/S15.3.4.3_A3_T2.js
+built-ins/Function/prototype/apply/S15.3.4.3_A3_T3.js
+built-ins/Function/prototype/apply/S15.3.4.3_A3_T4.js
+built-ins/Function/prototype/apply/S15.3.4.3_A3_T5.js
+built-ins/Function/prototype/apply/S15.3.4.3_A3_T7.js
+built-ins/Function/prototype/apply/S15.3.4.3_A3_T9.js
+built-ins/Function/prototype/apply/S15.3.4.3_A5_T1.js
+built-ins/Function/prototype/apply/S15.3.4.3_A5_T2.js
+built-ins/Function/prototype/apply/S15.3.4.3_A5_T7.js
+built-ins/Function/prototype/apply/S15.3.4.3_A5_T8.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T1.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T10.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T2.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T3.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T4.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T5.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T6.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T7.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T8.js
+built-ins/Function/prototype/apply/S15.3.4.3_A7_T9.js
+built-ins/Function/prototype/apply/S15.3.4.3_A8_T6.js
+built-ins/Function/prototype/bind/get-fn-realm-recursive.js
+built-ins/Function/prototype/bind/get-fn-realm.js
+built-ins/Function/prototype/bind/proto-from-ctor-realm.js
+built-ins/Function/prototype/call/S15.3.4.4_A3_T1.js
+built-ins/Function/prototype/call/S15.3.4.4_A3_T2.js
+built-ins/Function/prototype/call/S15.3.4.4_A3_T3.js
+built-ins/Function/prototype/call/S15.3.4.4_A3_T4.js
+built-ins/Function/prototype/call/S15.3.4.4_A3_T5.js
+built-ins/Function/prototype/call/S15.3.4.4_A3_T7.js
+built-ins/Function/prototype/call/S15.3.4.4_A3_T9.js
+built-ins/Function/prototype/call/S15.3.4.4_A5_T1.js
+built-ins/Function/prototype/call/S15.3.4.4_A5_T2.js
+built-ins/Function/prototype/call/S15.3.4.4_A5_T7.js
+built-ins/Function/prototype/call/S15.3.4.4_A5_T8.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T1.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T10.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T2.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T3.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T4.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T5.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T6.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T7.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T8.js
+built-ins/Function/prototype/call/S15.3.4.4_A6_T9.js
+built-ins/Function/prototype/call/S15.3.4.4_A7_T6.js
+built-ins/Function/prototype/toString/AsyncFunction.js
+built-ins/Function/prototype/toString/AsyncGenerator.js
+built-ins/Function/prototype/toString/Function.js
+built-ins/Function/prototype/toString/GeneratorFunction.js
+built-ins/Function/prototype/toString/arrow-function.js
+built-ins/Function/prototype/toString/async-arrow-function.js
+built-ins/Function/prototype/toString/async-function-declaration.js
+built-ins/Function/prototype/toString/async-function-expression.js
+built-ins/Function/prototype/toString/async-generator-declaration.js
+built-ins/Function/prototype/toString/async-generator-expression.js
+built-ins/Function/prototype/toString/async-generator-method-class-expression-static.js
+built-ins/Function/prototype/toString/async-generator-method-class-expression.js
+built-ins/Function/prototype/toString/async-generator-method-class-statement-static.js
+built-ins/Function/prototype/toString/async-generator-method-class-statement.js
+built-ins/Function/prototype/toString/async-generator-method-object.js
+built-ins/Function/prototype/toString/async-method-class-expression-static.js
+built-ins/Function/prototype/toString/async-method-class-expression.js
+built-ins/Function/prototype/toString/async-method-class-statement-static.js
+built-ins/Function/prototype/toString/async-method-class-statement.js
+built-ins/Function/prototype/toString/async-method-object.js
+built-ins/Function/prototype/toString/bound-function.js
+built-ins/Function/prototype/toString/built-in-function-object.js
+built-ins/Function/prototype/toString/class-declaration-complex-heritage.js
+built-ins/Function/prototype/toString/class-declaration-explicit-ctor.js
+built-ins/Function/prototype/toString/class-declaration-implicit-ctor.js
+built-ins/Function/prototype/toString/class-expression-explicit-ctor.js
+built-ins/Function/prototype/toString/class-expression-implicit-ctor.js
+built-ins/Function/prototype/toString/function-declaration-non-simple-parameter-list.js
+built-ins/Function/prototype/toString/function-declaration.js
+built-ins/Function/prototype/toString/function-expression.js
+built-ins/Function/prototype/toString/generator-function-declaration.js
+built-ins/Function/prototype/toString/generator-function-expression.js
+built-ins/Function/prototype/toString/generator-method.js
+built-ins/Function/prototype/toString/getter-class-expression-static.js
+built-ins/Function/prototype/toString/getter-class-expression.js
+built-ins/Function/prototype/toString/getter-class-statement-static.js
+built-ins/Function/prototype/toString/getter-class-statement.js
+built-ins/Function/prototype/toString/getter-object.js
+built-ins/Function/prototype/toString/line-terminator-normalisation-CR-LF.js
+built-ins/Function/prototype/toString/line-terminator-normalisation-CR.js
+built-ins/Function/prototype/toString/line-terminator-normalisation-LF.js
+built-ins/Function/prototype/toString/method-class-expression-static.js
+built-ins/Function/prototype/toString/method-class-expression.js
+built-ins/Function/prototype/toString/method-class-statement-static.js
+built-ins/Function/prototype/toString/method-class-statement.js
+built-ins/Function/prototype/toString/method-computed-property-name.js
+built-ins/Function/prototype/toString/method-object.js
+built-ins/Function/prototype/toString/proxy-arrow-function.js
+built-ins/Function/prototype/toString/proxy-async-function.js
+built-ins/Function/prototype/toString/proxy-async-generator-function.js
+built-ins/Function/prototype/toString/proxy-async-generator-method-definition.js
+built-ins/Function/prototype/toString/proxy-async-method-definition.js
+built-ins/Function/prototype/toString/proxy-bound-function.js
+built-ins/Function/prototype/toString/proxy-class.js
+built-ins/Function/prototype/toString/proxy-function-expression.js
+built-ins/Function/prototype/toString/proxy-generator-function.js
+built-ins/Function/prototype/toString/proxy-method-definition.js
+built-ins/Function/prototype/toString/setter-class-expression-static.js
+built-ins/Function/prototype/toString/setter-class-expression.js
+built-ins/Function/prototype/toString/setter-class-statement-static.js
+built-ins/Function/prototype/toString/setter-class-statement.js
+built-ins/Function/prototype/toString/setter-object.js
+built-ins/Function/prototype/toString/symbol-named-builtins.js
+built-ins/Function/prototype/toString/unicode.js
+built-ins/GeneratorFunction/has-instance.js
+built-ins/GeneratorFunction/instance-construct-throws.js
+built-ins/GeneratorFunction/instance-length.js
+built-ins/GeneratorFunction/instance-name.js
+built-ins/GeneratorFunction/instance-prototype.js
+built-ins/GeneratorFunction/instance-restricted-properties.js
+built-ins/GeneratorFunction/instance-yield-expr-in-param.js
+built-ins/GeneratorFunction/invoked-as-constructor-no-arguments.js
+built-ins/GeneratorFunction/invoked-as-function-multiple-arguments.js
+built-ins/GeneratorFunction/invoked-as-function-no-arguments.js
+built-ins/GeneratorFunction/invoked-as-function-single-argument.js
+built-ins/GeneratorFunction/proto-from-ctor-realm-prototype.js
+built-ins/GeneratorFunction/proto-from-ctor-realm.js
+built-ins/GeneratorPrototype/constructor.js
+built-ins/JSON/parse/revived-proxy.js
+built-ins/JSON/parse/reviver-array-delete-err.js
+built-ins/JSON/parse/reviver-call-order.js
+built-ins/JSON/parse/reviver-object-define-prop-err.js
+built-ins/JSON/parse/reviver-object-delete-err.js
+built-ins/JSON/parse/reviver-object-get-prop-from-prototype.js
+built-ins/JSON/parse/reviver-object-non-configurable-prop-create.js
+built-ins/JSON/parse/reviver-object-non-configurable-prop-delete.js
+built-ins/JSON/stringify/replacer-array-wrong-type.js
+built-ins/JSON/stringify/space-number-object.js
+built-ins/JSON/stringify/space-string-object.js
+built-ins/JSON/stringify/space-wrong-type.js
+built-ins/JSON/stringify/value-array-abrupt.js
+built-ins/JSON/stringify/value-array-proxy-revoked.js
+built-ins/JSON/stringify/value-array-proxy.js
+built-ins/JSON/stringify/value-bigint-cross-realm.js
+built-ins/JSON/stringify/value-number-object.js
+built-ins/JSON/stringify/value-object-proxy-revoked.js
+built-ins/JSON/stringify/value-object-proxy.js
+built-ins/JSON/stringify/value-string-escape-ascii.js
+built-ins/JSON/stringify/value-string-escape-unicode.js
+built-ins/JSON/stringify/value-string-object.js
+built-ins/Map/proto-from-ctor-realm.js
+built-ins/NativeErrors/AggregateError/errors-iterabletolist-failures.js
+built-ins/NativeErrors/AggregateError/errors-iterabletolist.js
+built-ins/NativeErrors/AggregateError/length.js
+built-ins/NativeErrors/AggregateError/message-method-prop-cast.js
+built-ins/NativeErrors/AggregateError/message-method-prop.js
+built-ins/NativeErrors/AggregateError/message-tostring-abrupt-symbol.js
+built-ins/NativeErrors/AggregateError/message-tostring-abrupt.js
+built-ins/NativeErrors/AggregateError/message-undefined-no-prop.js
+built-ins/NativeErrors/AggregateError/name.js
+built-ins/NativeErrors/AggregateError/newtarget-is-undefined.js
+built-ins/NativeErrors/AggregateError/newtarget-proto-custom.js
+built-ins/NativeErrors/AggregateError/newtarget-proto-fallback.js
+built-ins/NativeErrors/AggregateError/newtarget-proto.js
+built-ins/NativeErrors/AggregateError/prop-desc.js
+built-ins/NativeErrors/AggregateError/proto-from-ctor-realm.js
+built-ins/NativeErrors/AggregateError/proto.js
+built-ins/NativeErrors/AggregateError/prototype/constructor.js
+built-ins/NativeErrors/AggregateError/prototype/errors-absent-on-prototype.js
+built-ins/NativeErrors/AggregateError/prototype/message.js
+built-ins/NativeErrors/AggregateError/prototype/name.js
+built-ins/NativeErrors/AggregateError/prototype/prop-desc.js
+built-ins/NativeErrors/AggregateError/prototype/proto.js
+built-ins/NativeErrors/EvalError/proto-from-ctor-realm.js
+built-ins/NativeErrors/RangeError/proto-from-ctor-realm.js
+built-ins/NativeErrors/ReferenceError/proto-from-ctor-realm.js
+built-ins/NativeErrors/SyntaxError/proto-from-ctor-realm.js
+built-ins/NativeErrors/TypeError/proto-from-ctor-realm.js
+built-ins/NativeErrors/URIError/proto-from-ctor-realm.js
+built-ins/Number/proto-from-ctor-realm.js
+built-ins/Number/prototype/toExponential/return-values.js
+built-ins/Number/prototype/toExponential/this-is-0-fractiondigits-is-0.js
+built-ins/Number/prototype/toExponential/this-is-0-fractiondigits-is-not-0.js
+built-ins/Number/prototype/toPrecision/return-values.js
+built-ins/Number/prototype/toPrecision/this-is-0-precision-is-1.js
+built-ins/Number/prototype/toPrecision/this-is-0-precision-is-gter-than-1.js
+built-ins/Object/entries/order-after-define-property.js
+built-ins/Object/freeze/abrupt-completion.js
+built-ins/Object/freeze/throws-when-false.js
+built-ins/Object/fromEntries/evaluation-order.js
+built-ins/Object/getOwnPropertyDescriptor/15.2.3.3-4-187.js
+built-ins/Object/getOwnPropertyDescriptor/15.2.3.3-4-188.js
+built-ins/Object/getOwnPropertySymbols/order-after-define-property.js
+built-ins/Object/keys/order-after-define-property.js
+built-ins/Object/proto-from-ctor-realm.js
+built-ins/Object/prototype/toString/proxy-array.js
+built-ins/Object/prototype/toString/proxy-function-async.js
+built-ins/Object/prototype/toString/proxy-function.js
+built-ins/Object/prototype/toString/proxy-revoked-during-get-call.js
+built-ins/Object/prototype/toString/symbol-tag-non-str-bigint.js
+built-ins/Object/prototype/toString/symbol-tag-override-bigint.js
+built-ins/Object/seal/abrupt-completion.js
+built-ins/Object/seal/throws-when-false.js
+built-ins/Object/values/order-after-define-property.js
+built-ins/Promise/all/capability-resolve-throws-reject.js
+built-ins/Promise/all/invoke-resolve-error-reject.js
+built-ins/Promise/all/invoke-resolve-get-error-reject.js
+built-ins/Promise/all/invoke-resolve-get-error.js
+built-ins/Promise/all/invoke-resolve-get-once-multiple-calls.js
+built-ins/Promise/all/invoke-resolve-get-once-no-calls.js
+built-ins/Promise/all/invoke-then-error-reject.js
+built-ins/Promise/all/invoke-then-get-error-reject.js
+built-ins/Promise/all/resolve-element-function-name.js
+built-ins/Promise/all/resolve-non-callable.js
+built-ins/Promise/all/resolve-not-callable-reject-with-typeerror.js
+built-ins/Promise/all/species-get-error.js
+built-ins/Promise/allSettled/call-resolve-element-after-return.js
+built-ins/Promise/allSettled/call-resolve-element-items.js
+built-ins/Promise/allSettled/call-resolve-element.js
+built-ins/Promise/allSettled/capability-executor-called-twice.js
+built-ins/Promise/allSettled/capability-executor-not-callable.js
+built-ins/Promise/allSettled/capability-resolve-throws-no-close.js
+built-ins/Promise/allSettled/capability-resolve-throws-reject.js
+built-ins/Promise/allSettled/ctx-ctor-throws.js
+built-ins/Promise/allSettled/ctx-ctor.js
+built-ins/Promise/allSettled/does-not-invoke-array-setters.js
+built-ins/Promise/allSettled/invoke-resolve-error-close.js
+built-ins/Promise/allSettled/invoke-resolve-error-reject.js
+built-ins/Promise/allSettled/invoke-resolve-get-error-reject.js
+built-ins/Promise/allSettled/invoke-resolve-get-error.js
+built-ins/Promise/allSettled/invoke-resolve-get-once-multiple-calls.js
+built-ins/Promise/allSettled/invoke-resolve-get-once-no-calls.js
+built-ins/Promise/allSettled/invoke-resolve-on-promises-every-iteration-of-custom.js
+built-ins/Promise/allSettled/invoke-resolve-on-promises-every-iteration-of-promise.js
+built-ins/Promise/allSettled/invoke-resolve-on-values-every-iteration-of-promise.js
+built-ins/Promise/allSettled/invoke-resolve-return.js
+built-ins/Promise/allSettled/invoke-resolve.js
+built-ins/Promise/allSettled/invoke-then-error-close.js
+built-ins/Promise/allSettled/invoke-then-error-reject.js
+built-ins/Promise/allSettled/invoke-then-get-error-close.js
+built-ins/Promise/allSettled/invoke-then-get-error-reject.js
+built-ins/Promise/allSettled/invoke-then.js
+built-ins/Promise/allSettled/is-function.js
+built-ins/Promise/allSettled/iter-arg-is-false-reject.js
+built-ins/Promise/allSettled/iter-arg-is-null-reject.js
+built-ins/Promise/allSettled/iter-arg-is-number-reject.js
+built-ins/Promise/allSettled/iter-arg-is-poisoned.js
+built-ins/Promise/allSettled/iter-arg-is-string-resolve.js
+built-ins/Promise/allSettled/iter-arg-is-symbol-reject.js
+built-ins/Promise/allSettled/iter-arg-is-true-reject.js
+built-ins/Promise/allSettled/iter-arg-is-undefined-reject.js
+built-ins/Promise/allSettled/iter-assigned-false-reject.js
+built-ins/Promise/allSettled/iter-assigned-null-reject.js
+built-ins/Promise/allSettled/iter-assigned-number-reject.js
+built-ins/Promise/allSettled/iter-assigned-string-reject.js
+built-ins/Promise/allSettled/iter-assigned-symbol-reject.js
+built-ins/Promise/allSettled/iter-assigned-true-reject.js
+built-ins/Promise/allSettled/iter-assigned-undefined-reject.js
+built-ins/Promise/allSettled/iter-next-err-reject.js
+built-ins/Promise/allSettled/iter-next-val-err-no-close.js
+built-ins/Promise/allSettled/iter-next-val-err-reject.js
+built-ins/Promise/allSettled/iter-returns-false-reject.js
+built-ins/Promise/allSettled/iter-returns-null-reject.js
+built-ins/Promise/allSettled/iter-returns-number-reject.js
+built-ins/Promise/allSettled/iter-returns-string-reject.js
+built-ins/Promise/allSettled/iter-returns-symbol-reject.js
+built-ins/Promise/allSettled/iter-returns-true-reject.js
+built-ins/Promise/allSettled/iter-returns-undefined-reject.js
+built-ins/Promise/allSettled/iter-step-err-no-close.js
+built-ins/Promise/allSettled/iter-step-err-reject.js
+built-ins/Promise/allSettled/length.js
+built-ins/Promise/allSettled/name.js
+built-ins/Promise/allSettled/new-reject-function.js
+built-ins/Promise/allSettled/new-resolve-function.js
+built-ins/Promise/allSettled/prop-desc.js
+built-ins/Promise/allSettled/reject-deferred.js
+built-ins/Promise/allSettled/reject-element-function-extensible.js
+built-ins/Promise/allSettled/reject-element-function-length.js
+built-ins/Promise/allSettled/reject-element-function-multiple-calls.js
+built-ins/Promise/allSettled/reject-element-function-name.js
+built-ins/Promise/allSettled/reject-element-function-nonconstructor.js
+built-ins/Promise/allSettled/reject-element-function-prototype.js
+built-ins/Promise/allSettled/reject-ignored-deferred.js
+built-ins/Promise/allSettled/reject-ignored-immed.js
+built-ins/Promise/allSettled/reject-immed.js
+built-ins/Promise/allSettled/resolve-before-loop-exit-from-same.js
+built-ins/Promise/allSettled/resolve-before-loop-exit.js
+built-ins/Promise/allSettled/resolve-element-function-extensible.js
+built-ins/Promise/allSettled/resolve-element-function-length.js
+built-ins/Promise/allSettled/resolve-element-function-name.js
+built-ins/Promise/allSettled/resolve-element-function-nonconstructor.js
+built-ins/Promise/allSettled/resolve-element-function-prototype.js
+built-ins/Promise/allSettled/resolve-from-same-thenable.js
+built-ins/Promise/allSettled/resolve-ignores-late-rejection-deferred.js
+built-ins/Promise/allSettled/resolve-ignores-late-rejection.js
+built-ins/Promise/allSettled/resolve-non-callable.js
+built-ins/Promise/allSettled/resolve-non-thenable.js
+built-ins/Promise/allSettled/resolve-not-callable-reject-with-typeerror.js
+built-ins/Promise/allSettled/resolve-poisoned-then.js
+built-ins/Promise/allSettled/resolve-thenable.js
+built-ins/Promise/allSettled/resolved-all-fulfilled.js
+built-ins/Promise/allSettled/resolved-all-mixed.js
+built-ins/Promise/allSettled/resolved-all-rejected.js
+built-ins/Promise/allSettled/resolved-immed.js
+built-ins/Promise/allSettled/resolved-sequence-extra-ticks.js
+built-ins/Promise/allSettled/resolved-sequence-mixed.js
+built-ins/Promise/allSettled/resolved-sequence-with-rejections.js
+built-ins/Promise/allSettled/resolved-sequence.js
+built-ins/Promise/allSettled/resolved-then-catch-finally.js
+built-ins/Promise/allSettled/resolves-empty-array.js
+built-ins/Promise/allSettled/resolves-to-array.js
+built-ins/Promise/allSettled/returns-promise.js
+built-ins/Promise/allSettled/species-get-error.js
+built-ins/Promise/any/call-reject-element-after-return.js
+built-ins/Promise/any/call-reject-element-items.js
+built-ins/Promise/any/capability-executor-called-twice.js
+built-ins/Promise/any/capability-executor-not-callable.js
+built-ins/Promise/any/capability-reject-throws-no-close.js
+built-ins/Promise/any/capability-resolve-throws-no-close.js
+built-ins/Promise/any/capability-resolve-throws-reject.js
+built-ins/Promise/any/ctx-ctor-throws.js
+built-ins/Promise/any/ctx-ctor.js
+built-ins/Promise/any/ctx-non-ctor.js
+built-ins/Promise/any/invoke-resolve-error-close.js
+built-ins/Promise/any/invoke-resolve-error-reject.js
+built-ins/Promise/any/invoke-resolve-get-error-reject.js
+built-ins/Promise/any/invoke-resolve-get-error.js
+built-ins/Promise/any/invoke-resolve-get-once-multiple-calls.js
+built-ins/Promise/any/invoke-resolve-get-once-no-calls.js
+built-ins/Promise/any/invoke-resolve-on-promises-every-iteration-of-custom.js
+built-ins/Promise/any/invoke-resolve-on-promises-every-iteration-of-promise.js
+built-ins/Promise/any/invoke-resolve-on-values-every-iteration-of-custom.js
+built-ins/Promise/any/invoke-resolve-on-values-every-iteration-of-promise.js
+built-ins/Promise/any/invoke-resolve-return.js
+built-ins/Promise/any/invoke-resolve.js
+built-ins/Promise/any/invoke-then-error-close.js
+built-ins/Promise/any/invoke-then-error-reject.js
+built-ins/Promise/any/invoke-then-get-error-close.js
+built-ins/Promise/any/invoke-then-get-error-reject.js
+built-ins/Promise/any/invoke-then-on-promises-every-iteration.js
+built-ins/Promise/any/invoke-then.js
+built-ins/Promise/any/is-function.js
+built-ins/Promise/any/iter-arg-is-empty-iterable-reject.js
+built-ins/Promise/any/iter-arg-is-empty-string-reject.js
+built-ins/Promise/any/iter-arg-is-error-object-reject.js
+built-ins/Promise/any/iter-arg-is-false-reject.js
+built-ins/Promise/any/iter-arg-is-null-reject.js
+built-ins/Promise/any/iter-arg-is-number-reject.js
+built-ins/Promise/any/iter-arg-is-poisoned.js
+built-ins/Promise/any/iter-arg-is-string-resolve.js
+built-ins/Promise/any/iter-arg-is-symbol-reject.js
+built-ins/Promise/any/iter-arg-is-true-reject.js
+built-ins/Promise/any/iter-arg-is-undefined-reject.js
+built-ins/Promise/any/iter-assigned-false-reject.js
+built-ins/Promise/any/iter-assigned-null-reject.js
+built-ins/Promise/any/iter-assigned-number-reject.js
+built-ins/Promise/any/iter-assigned-string-reject.js
+built-ins/Promise/any/iter-assigned-symbol-reject.js
+built-ins/Promise/any/iter-assigned-true-reject.js
+built-ins/Promise/any/iter-assigned-undefined-reject.js
+built-ins/Promise/any/iter-next-val-err-no-close.js
+built-ins/Promise/any/iter-next-val-err-reject.js
+built-ins/Promise/any/iter-returns-false-reject.js
+built-ins/Promise/any/iter-returns-null-reject.js
+built-ins/Promise/any/iter-returns-number-reject.js
+built-ins/Promise/any/iter-returns-string-reject.js
+built-ins/Promise/any/iter-returns-symbol-reject.js
+built-ins/Promise/any/iter-returns-true-reject.js
+built-ins/Promise/any/iter-returns-undefined-reject.js
+built-ins/Promise/any/iter-step-err-no-close.js
+built-ins/Promise/any/iter-step-err-reject.js
+built-ins/Promise/any/length.js
+built-ins/Promise/any/name.js
+built-ins/Promise/any/new-reject-function.js
+built-ins/Promise/any/prop-desc.js
+built-ins/Promise/any/reject-all-mixed.js
+built-ins/Promise/any/reject-deferred.js
+built-ins/Promise/any/reject-element-function-extensible.js
+built-ins/Promise/any/reject-element-function-length.js
+built-ins/Promise/any/reject-element-function-name.js
+built-ins/Promise/any/reject-element-function-nonconstructor.js
+built-ins/Promise/any/reject-element-function-prototype.js
+built-ins/Promise/any/reject-from-same-thenable.js
+built-ins/Promise/any/reject-ignored-immed.js
+built-ins/Promise/any/reject-immed.js
+built-ins/Promise/any/resolve-before-loop-exit-from-same.js
+built-ins/Promise/any/resolve-before-loop-exit.js
+built-ins/Promise/any/resolve-from-reject-catch.js
+built-ins/Promise/any/resolve-from-resolve-reject-catch.js
+built-ins/Promise/any/resolve-from-same-thenable.js
+built-ins/Promise/any/resolve-ignores-late-rejection-deferred.js
+built-ins/Promise/any/resolve-ignores-late-rejection.js
+built-ins/Promise/any/resolve-non-callable.js
+built-ins/Promise/any/resolve-non-thenable.js
+built-ins/Promise/any/resolve-not-callable-reject-with-typeerror.js
+built-ins/Promise/any/resolved-sequence-extra-ticks.js
+built-ins/Promise/any/resolved-sequence-mixed.js
+built-ins/Promise/any/resolved-sequence-with-rejections.js
+built-ins/Promise/any/resolved-sequence.js
+built-ins/Promise/any/returns-promise.js
+built-ins/Promise/any/species-get-error.js
+built-ins/Promise/executor-function-name.js
+built-ins/Promise/get-prototype-abrupt.js
+built-ins/Promise/proto-from-ctor-realm.js
+built-ins/Promise/prototype/finally/invokes-then-with-function.js
+built-ins/Promise/prototype/finally/invokes-then-with-non-function.js
+built-ins/Promise/prototype/finally/is-a-function.js
+built-ins/Promise/prototype/finally/length.js
+built-ins/Promise/prototype/finally/name.js
+built-ins/Promise/prototype/finally/prop-desc.js
+built-ins/Promise/prototype/finally/rejected-observable-then-calls-argument.js
+built-ins/Promise/prototype/finally/rejected-observable-then-calls.js
+built-ins/Promise/prototype/finally/rejection-reason-no-fulfill.js
+built-ins/Promise/prototype/finally/rejection-reason-override-with-throw.js
+built-ins/Promise/prototype/finally/resolution-value-no-override.js
+built-ins/Promise/prototype/finally/resolved-observable-then-calls-argument.js
+built-ins/Promise/prototype/finally/resolved-observable-then-calls.js
+built-ins/Promise/prototype/finally/species-constructor.js
+built-ins/Promise/prototype/finally/species-symbol.js
+built-ins/Promise/prototype/finally/subclass-reject-count.js
+built-ins/Promise/prototype/finally/subclass-resolve-count.js
+built-ins/Promise/prototype/finally/subclass-species-constructor-reject-count.js
+built-ins/Promise/prototype/finally/subclass-species-constructor-resolve-count.js
+built-ins/Promise/prototype/finally/this-value-non-object.js
+built-ins/Promise/prototype/finally/this-value-proxy.js
+built-ins/Promise/prototype/finally/this-value-then-not-callable.js
+built-ins/Promise/prototype/finally/this-value-then-poisoned.js
+built-ins/Promise/prototype/finally/this-value-then-throws.js
+built-ins/Promise/prototype/finally/this-value-thenable.js
+built-ins/Promise/race/invoke-resolve-get-error.js
+built-ins/Promise/race/invoke-resolve-get-once-multiple-calls.js
+built-ins/Promise/race/invoke-resolve-get-once-no-calls.js
+built-ins/Promise/race/invoke-resolve-on-promises-every-iteration-of-custom.js
+built-ins/Promise/race/invoke-resolve-on-promises-every-iteration-of-promise.js
+built-ins/Promise/race/invoke-resolve-on-values-every-iteration-of-promise.js
+built-ins/Promise/race/resolve-non-callable.js
+built-ins/Promise/race/resolved-then-catch-finally.js
+built-ins/Promise/race/species-get-error.js
+built-ins/Promise/reject-function-name.js
+built-ins/Promise/resolve-function-name.js
+built-ins/Proxy/apply/arguments-realm.js
+built-ins/Proxy/apply/trap-is-undefined-target-is-proxy.js
+built-ins/Proxy/construct/arguments-realm.js
+built-ins/Proxy/construct/call-parameters.js
+built-ins/Proxy/construct/trap-is-undefined-proto-from-cross-realm-newtarget.js
+built-ins/Proxy/construct/trap-is-undefined-proto-from-newtarget-realm.js
+built-ins/Proxy/get-fn-realm-recursive.js
+built-ins/Proxy/get-fn-realm.js
+built-ins/Proxy/preventExtensions/trap-is-undefined-target-is-proxy.js
+built-ins/Reflect/ownKeys/order-after-define-property.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-flags-u.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-plus-quantifier-flags-u.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-plus-quantifier.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-flags-u.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-plus-quantifier-flags-u.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-plus-quantifier.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-flags-u.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-plus-quantifier-flags-u.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-plus-quantifier.js
+built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape.js
+built-ins/RegExp/S15.10.4.1_A5_T3.js
+built-ins/RegExp/S15.10.4.1_A8_T11.js
+built-ins/RegExp/lookBehind/back-references-to-captures.js
+built-ins/RegExp/lookBehind/captures.js
+built-ins/RegExp/lookBehind/greedy-loop.js
+built-ins/RegExp/lookBehind/negative.js
+built-ins/RegExp/lookBehind/nested-lookaround.js
+built-ins/RegExp/lookBehind/simple-fixed-length.js
+built-ins/RegExp/lookBehind/start-of-line.js
+built-ins/RegExp/lookBehind/sticky.js
+built-ins/RegExp/match-indices/indices-array-element.js
+built-ins/RegExp/match-indices/indices-array-matched.js
+built-ins/RegExp/match-indices/indices-array-non-unicode-match.js
+built-ins/RegExp/match-indices/indices-array-properties.js
+built-ins/RegExp/match-indices/indices-array-unicode-match.js
+built-ins/RegExp/match-indices/indices-array-unicode-property-names.js
+built-ins/RegExp/match-indices/indices-array-unmatched.js
+built-ins/RegExp/match-indices/indices-array.js
+built-ins/RegExp/match-indices/indices-groups-object-undefined.js
+built-ins/RegExp/match-indices/indices-groups-object-unmatched.js
+built-ins/RegExp/match-indices/indices-groups-object.js
+built-ins/RegExp/match-indices/indices-groups-properties.js
+built-ins/RegExp/match-indices/indices-property.js
+built-ins/RegExp/named-groups/functional-replace-global.js
+built-ins/RegExp/named-groups/functional-replace-non-global.js
+built-ins/RegExp/named-groups/groups-object-subclass-sans.js
+built-ins/RegExp/named-groups/groups-object-subclass.js
+built-ins/RegExp/named-groups/groups-object-undefined.js
+built-ins/RegExp/named-groups/groups-object-unmatched.js
+built-ins/RegExp/named-groups/groups-object.js
+built-ins/RegExp/named-groups/groups-properties.js
+built-ins/RegExp/named-groups/lookbehind.js
+built-ins/RegExp/named-groups/non-unicode-match.js
+built-ins/RegExp/named-groups/non-unicode-property-names-invalid.js
+built-ins/RegExp/named-groups/non-unicode-property-names.js
+built-ins/RegExp/named-groups/string-replace-get.js
+built-ins/RegExp/named-groups/string-replace-missing.js
+built-ins/RegExp/named-groups/string-replace-undefined.js
+built-ins/RegExp/named-groups/unicode-match.js
+built-ins/RegExp/named-groups/unicode-property-names-invalid.js
+built-ins/RegExp/named-groups/unicode-property-names-valid.js
+built-ins/RegExp/proto-from-ctor-realm.js
+built-ins/RegExp/prototype/Symbol.match/builtin-success-g-set-lastindex.js
+built-ins/RegExp/prototype/Symbol.matchAll/isregexp-called-once.js
+built-ins/RegExp/prototype/Symbol.matchAll/isregexp-this-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/length.js
+built-ins/RegExp/prototype/Symbol.matchAll/name.js
+built-ins/RegExp/prototype/Symbol.matchAll/prop-desc.js
+built-ins/RegExp/prototype/Symbol.matchAll/regexpcreate-this-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-constructor-get-constructor-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-constructor-get-species-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-constructor-is-undefined.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-constructor-species-is-null-or-undefined.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-constructor-species-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-constructor.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-regexp-get-global-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/species-regexp-get-unicode-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/string-tostring-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/string-tostring.js
+built-ins/RegExp/prototype/Symbol.matchAll/this-get-flags-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/this-get-flags.js
+built-ins/RegExp/prototype/Symbol.matchAll/this-lastindex-cached.js
+built-ins/RegExp/prototype/Symbol.matchAll/this-tolength-lastindex-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/this-tostring-flags-throws.js
+built-ins/RegExp/prototype/Symbol.matchAll/this-tostring-flags.js
+built-ins/RegExp/prototype/Symbol.replace/coerce-lastindex-err.js
+built-ins/RegExp/prototype/Symbol.replace/coerce-lastindex.js
+built-ins/RegExp/prototype/Symbol.replace/fn-invoke-args-empty-result.js
+built-ins/RegExp/prototype/Symbol.replace/named-groups-fn.js
+built-ins/RegExp/prototype/Symbol.replace/named-groups.js
+built-ins/RegExp/prototype/Symbol.replace/poisoned-stdlib.js
+built-ins/RegExp/prototype/Symbol.replace/result-coerce-groups-err.js
+built-ins/RegExp/prototype/Symbol.replace/result-coerce-groups-prop-err.js
+built-ins/RegExp/prototype/Symbol.replace/result-coerce-groups-prop.js
+built-ins/RegExp/prototype/Symbol.replace/result-coerce-groups.js
+built-ins/RegExp/prototype/Symbol.replace/result-get-groups-err.js
+built-ins/RegExp/prototype/Symbol.replace/result-get-groups-prop-err.js
+built-ins/RegExp/prototype/Symbol.split/last-index-exceeds-str-size.js
+built-ins/RegExp/prototype/Symbol.split/splitter-proto-from-ctor-realm.js
+built-ins/RegExp/prototype/dotAll/this-val-regexp-prototype.js
+built-ins/RegExp/prototype/flags/coercion-dotall.js
+built-ins/RegExp/prototype/flags/get-order.js
+built-ins/RegExp/prototype/flags/rethrow.js
+built-ins/RegExp/prototype/flags/return-order.js
+built-ins/RegExp/prototype/flags/this-val-regexp-prototype.js
+built-ins/RegExp/prototype/flags/this-val-regexp.js
+built-ins/RegExp/prototype/global/this-val-regexp-prototype.js
+built-ins/RegExp/prototype/ignoreCase/this-val-regexp-prototype.js
+built-ins/RegExp/prototype/multiline/this-val-regexp-prototype.js
+built-ins/RegExp/prototype/source/this-val-regexp-prototype.js
+built-ins/RegExp/prototype/source/value-empty.js
+built-ins/RegExp/prototype/source/value-line-terminator.js
+built-ins/RegExp/prototype/source/value-slash.js
+built-ins/RegExp/prototype/source/value-u.js
+built-ins/RegExp/prototype/source/value.js
+built-ins/RegExp/prototype/sticky/this-val-regexp-prototype.js
+built-ins/RegExp/prototype/unicode/this-val-regexp-prototype.js
+built-ins/RegExp/quantifier-integer-limit.js
+built-ins/RegExpStringIteratorPrototype/Symbol.toStringTag.js
+built-ins/RegExpStringIteratorPrototype/ancestry.js
+built-ins/RegExpStringIteratorPrototype/next/custom-regexpexec-call-throws.js
+built-ins/RegExpStringIteratorPrototype/next/custom-regexpexec-get-throws.js
+built-ins/RegExpStringIteratorPrototype/next/custom-regexpexec-match-get-0-throws.js
+built-ins/RegExpStringIteratorPrototype/next/custom-regexpexec-match-get-0-tostring-throws.js
+built-ins/RegExpStringIteratorPrototype/next/custom-regexpexec-match-get-0-tostring.js
+built-ins/RegExpStringIteratorPrototype/next/custom-regexpexec-not-callable.js
+built-ins/RegExpStringIteratorPrototype/next/custom-regexpexec.js
+built-ins/RegExpStringIteratorPrototype/next/length.js
+built-ins/RegExpStringIteratorPrototype/next/name.js
+built-ins/RegExpStringIteratorPrototype/next/next-iteration-global.js
+built-ins/RegExpStringIteratorPrototype/next/next-iteration.js
+built-ins/RegExpStringIteratorPrototype/next/next-missing-internal-slots.js
+built-ins/RegExpStringIteratorPrototype/next/prop-desc.js
+built-ins/RegExpStringIteratorPrototype/next/regexp-tolength-lastindex-throws.js
+built-ins/RegExpStringIteratorPrototype/next/this-is-not-object-throws.js
+built-ins/Set/proto-from-ctor-realm.js
+built-ins/SharedArrayBuffer/allocation-limit.js
+built-ins/SharedArrayBuffer/data-allocation-after-object-creation.js
+built-ins/SharedArrayBuffer/init-zero.js
+built-ins/SharedArrayBuffer/length-is-absent.js
+built-ins/SharedArrayBuffer/length-is-too-large-throws.js
+built-ins/SharedArrayBuffer/length.js
+built-ins/SharedArrayBuffer/negative-length-throws.js
+built-ins/SharedArrayBuffer/newtarget-prototype-is-not-object.js
+built-ins/SharedArrayBuffer/proto-from-ctor-realm.js
+built-ins/SharedArrayBuffer/prototype-from-newtarget.js
+built-ins/SharedArrayBuffer/prototype/Symbol.toStringTag.js
+built-ins/SharedArrayBuffer/prototype/byteLength/invoked-as-accessor.js
+built-ins/SharedArrayBuffer/prototype/byteLength/invoked-as-func.js
+built-ins/SharedArrayBuffer/prototype/byteLength/length.js
+built-ins/SharedArrayBuffer/prototype/byteLength/name.js
+built-ins/SharedArrayBuffer/prototype/byteLength/prop-desc.js
+built-ins/SharedArrayBuffer/prototype/byteLength/return-bytelength.js
+built-ins/SharedArrayBuffer/prototype/byteLength/this-has-no-typedarrayname-internal.js
+built-ins/SharedArrayBuffer/prototype/byteLength/this-is-arraybuffer.js
+built-ins/SharedArrayBuffer/prototype/byteLength/this-is-not-object.js
+built-ins/SharedArrayBuffer/prototype/constructor.js
+built-ins/SharedArrayBuffer/prototype/slice/context-is-not-arraybuffer-object.js
+built-ins/SharedArrayBuffer/prototype/slice/context-is-not-object.js
+built-ins/SharedArrayBuffer/prototype/slice/descriptor.js
+built-ins/SharedArrayBuffer/prototype/slice/end-default-if-absent.js
+built-ins/SharedArrayBuffer/prototype/slice/end-default-if-undefined.js
+built-ins/SharedArrayBuffer/prototype/slice/end-exceeds-length.js
+built-ins/SharedArrayBuffer/prototype/slice/extensible.js
+built-ins/SharedArrayBuffer/prototype/slice/length.js
+built-ins/SharedArrayBuffer/prototype/slice/name.js
+built-ins/SharedArrayBuffer/prototype/slice/negative-end.js
+built-ins/SharedArrayBuffer/prototype/slice/negative-start.js
+built-ins/SharedArrayBuffer/prototype/slice/nonconstructor.js
+built-ins/SharedArrayBuffer/prototype/slice/number-conversion.js
+built-ins/SharedArrayBuffer/prototype/slice/species-constructor-is-not-object.js
+built-ins/SharedArrayBuffer/prototype/slice/species-constructor-is-undefined.js
+built-ins/SharedArrayBuffer/prototype/slice/species-is-not-constructor.js
+built-ins/SharedArrayBuffer/prototype/slice/species-is-not-object.js
+built-ins/SharedArrayBuffer/prototype/slice/species-is-null.js
+built-ins/SharedArrayBuffer/prototype/slice/species-is-undefined.js
+built-ins/SharedArrayBuffer/prototype/slice/species-returns-larger-arraybuffer.js
+built-ins/SharedArrayBuffer/prototype/slice/species-returns-not-arraybuffer.js
+built-ins/SharedArrayBuffer/prototype/slice/species-returns-same-arraybuffer.js
+built-ins/SharedArrayBuffer/prototype/slice/species-returns-smaller-arraybuffer.js
+built-ins/SharedArrayBuffer/prototype/slice/species.js
+built-ins/SharedArrayBuffer/prototype/slice/start-default-if-absent.js
+built-ins/SharedArrayBuffer/prototype/slice/start-default-if-undefined.js
+built-ins/SharedArrayBuffer/prototype/slice/start-exceeds-end.js
+built-ins/SharedArrayBuffer/prototype/slice/start-exceeds-length.js
+built-ins/SharedArrayBuffer/prototype/slice/this-is-arraybuffer.js
+built-ins/SharedArrayBuffer/prototype/slice/tointeger-conversion-end.js
+built-ins/SharedArrayBuffer/prototype/slice/tointeger-conversion-start.js
+built-ins/SharedArrayBuffer/return-abrupt-from-length-symbol.js
+built-ins/SharedArrayBuffer/return-abrupt-from-length.js
+built-ins/SharedArrayBuffer/toindex-length.js
+built-ins/SharedArrayBuffer/undefined-newtarget-throws.js
+built-ins/SharedArrayBuffer/zero-length.js
+built-ins/String/S9.8_A1_T1.js
+built-ins/String/proto-from-ctor-realm.js
+built-ins/String/prototype/charAt/S15.5.4.4_A1.1.js
+built-ins/String/prototype/charCodeAt/S15.5.4.5_A1.1.js
+built-ins/String/prototype/indexOf/S15.5.4.7_A3_T2.js
+built-ins/String/prototype/indexOf/position-tointeger-toprimitive.js
+built-ins/String/prototype/indexOf/position-tointeger.js
+built-ins/String/prototype/indexOf/searchstring-tostring-toprimitive.js
+built-ins/String/prototype/match/S15.5.4.10_A1_T3.js
+built-ins/String/prototype/matchAll/length.js
+built-ins/String/prototype/matchAll/name.js
+built-ins/String/prototype/matchAll/prop-desc.js
+built-ins/String/prototype/matchAll/regexp-get-matchAll-throws.js
+built-ins/String/prototype/matchAll/regexp-is-null.js
+built-ins/String/prototype/matchAll/regexp-is-undefined-or-null-invokes-matchAll.js
+built-ins/String/prototype/matchAll/regexp-is-undefined.js
+built-ins/String/prototype/matchAll/regexp-matchAll-invocation.js
+built-ins/String/prototype/matchAll/regexp-matchAll-is-undefined-or-null.js
+built-ins/String/prototype/matchAll/regexp-matchAll-not-callable.js
+built-ins/String/prototype/matchAll/regexp-matchAll-throws.js
+built-ins/String/prototype/matchAll/regexp-prototype-get-matchAll-throws.js
+built-ins/String/prototype/matchAll/regexp-prototype-has-no-matchAll.js
+built-ins/String/prototype/matchAll/regexp-prototype-matchAll-invocation.js
+built-ins/String/prototype/matchAll/regexp-prototype-matchAll-throws.js
+built-ins/String/prototype/matchAll/this-val-non-obj-coercible.js
+built-ins/String/prototype/matchAll/toString-this-val.js
+built-ins/String/prototype/normalize/return-normalized-string.js
+built-ins/String/prototype/padEnd/normal-operation.js
+built-ins/String/prototype/padStart/normal-operation.js
+built-ins/String/prototype/replace/S15.5.4.11_A1_T6.js
+built-ins/String/prototype/replaceAll/searchValue-replacer-RegExp-call.js
+built-ins/String/prototype/split/S15.5.4.14_A1_T11.js
+built-ins/String/prototype/split/S15.5.4.14_A1_T12.js
+built-ins/String/prototype/split/S15.5.4.14_A1_T14.js
+built-ins/String/prototype/split/S15.5.4.14_A1_T15.js
+built-ins/String/prototype/split/S15.5.4.14_A1_T18.js
+built-ins/String/prototype/split/S15.5.4.14_A1_T3.js
+built-ins/String/prototype/toLocaleLowerCase/S15.5.4.17_A1_T3.js
+built-ins/String/prototype/toLocaleUpperCase/S15.5.4.19_A1_T3.js
+built-ins/String/prototype/toLowerCase/S15.5.4.16_A1_T3.js
+built-ins/String/prototype/toUpperCase/S15.5.4.18_A1_T3.js
+built-ins/Symbol/matchAll/prop-desc.js
+built-ins/ThrowTypeError/distinct-cross-realm.js
+built-ins/ThrowTypeError/length.js
+built-ins/ThrowTypeError/name.js
+built-ins/ThrowTypeError/unique-per-realm-function-proto.js
+built-ins/TypedArray/prototype/Symbol.toStringTag/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/Symbol.toStringTag/BigInt/return-typedarrayname.js
+built-ins/TypedArray/prototype/Symbol.toStringTag/detached-buffer.js
+built-ins/TypedArray/prototype/buffer/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/buffer/BigInt/return-buffer.js
+built-ins/TypedArray/prototype/buffer/detached-buffer.js
+built-ins/TypedArray/prototype/byteLength/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/byteLength/BigInt/return-bytelength.js
+built-ins/TypedArray/prototype/byteLength/detached-buffer.js
+built-ins/TypedArray/prototype/byteOffset/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/byteOffset/BigInt/return-byteoffset.js
+built-ins/TypedArray/prototype/byteOffset/detached-buffer.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/get-length-ignores-length-prop.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/return-abrupt-from-end-is-symbol.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/return-abrupt-from-end.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/return-abrupt-from-start-is-symbol.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/return-abrupt-from-start.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/return-abrupt-from-target-is-symbol.js
+built-ins/TypedArray/prototype/copyWithin/BigInt/return-abrupt-from-target.js
+built-ins/TypedArray/prototype/copyWithin/coerced-values-end-detached-prototype.js
+built-ins/TypedArray/prototype/copyWithin/coerced-values-end-detached.js
+built-ins/TypedArray/prototype/copyWithin/coerced-values-start-detached.js
+built-ins/TypedArray/prototype/copyWithin/detached-buffer.js
+built-ins/TypedArray/prototype/entries/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/entries/detached-buffer.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-not-callable-throws.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-not-called-on-empty.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-returns-abrupt.js
+built-ins/TypedArray/prototype/every/BigInt/callbackfn-this.js
+built-ins/TypedArray/prototype/every/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/every/BigInt/returns-false-if-any-cb-returns-false.js
+built-ins/TypedArray/prototype/every/BigInt/returns-true-if-every-cb-returns-true.js
+built-ins/TypedArray/prototype/every/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/every/detached-buffer.js
+built-ins/TypedArray/prototype/fill/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/fill/BigInt/fill-values-symbol-throws.js
+built-ins/TypedArray/prototype/fill/coerced-end-detach.js
+built-ins/TypedArray/prototype/fill/coerced-start-detach.js
+built-ins/TypedArray/prototype/fill/coerced-value-detach.js
+built-ins/TypedArray/prototype/fill/detached-buffer.js
+built-ins/TypedArray/prototype/filter/BigInt/arraylength-internal.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-called-before-ctor.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-called-before-species.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-not-callable-throws.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-not-called-on-empty.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-returns-abrupt.js
+built-ins/TypedArray/prototype/filter/BigInt/callbackfn-this.js
+built-ins/TypedArray/prototype/filter/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/filter/BigInt/result-empty-callbackfn-returns-false.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-abrupt.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-custom-ctor-length-throws.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-custom-ctor-length.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-custom-ctor-throws.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-returns-throws.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species-use-default-ctor.js
+built-ins/TypedArray/prototype/filter/BigInt/speciesctor-get-species.js
+built-ins/TypedArray/prototype/filter/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/filter/detached-buffer.js
+built-ins/TypedArray/prototype/find/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/find/BigInt/predicate-call-this-strict.js
+built-ins/TypedArray/prototype/find/BigInt/predicate-is-not-callable-throws.js
+built-ins/TypedArray/prototype/find/BigInt/predicate-may-detach-buffer.js
+built-ins/TypedArray/prototype/find/BigInt/predicate-not-called-on-empty-array.js
+built-ins/TypedArray/prototype/find/BigInt/return-abrupt-from-predicate-call.js
+built-ins/TypedArray/prototype/find/BigInt/return-undefined-if-predicate-returns-false-value.js
+built-ins/TypedArray/prototype/find/detached-buffer.js
+built-ins/TypedArray/prototype/find/predicate-may-detach-buffer.js
+built-ins/TypedArray/prototype/findIndex/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/findIndex/BigInt/predicate-call-this-strict.js
+built-ins/TypedArray/prototype/findIndex/BigInt/predicate-is-not-callable-throws.js
+built-ins/TypedArray/prototype/findIndex/BigInt/predicate-may-detach-buffer.js
+built-ins/TypedArray/prototype/findIndex/BigInt/predicate-not-called-on-empty-array.js
+built-ins/TypedArray/prototype/findIndex/BigInt/return-abrupt-from-predicate-call.js
+built-ins/TypedArray/prototype/findIndex/detached-buffer.js
+built-ins/TypedArray/prototype/findIndex/predicate-may-detach-buffer.js
+built-ins/TypedArray/prototype/forEach/BigInt/arraylength-internal.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-is-not-callable.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-not-called-on-empty.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-returns-abrupt.js
+built-ins/TypedArray/prototype/forEach/BigInt/callbackfn-this.js
+built-ins/TypedArray/prototype/forEach/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/forEach/BigInt/returns-undefined.js
+built-ins/TypedArray/prototype/forEach/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/forEach/detached-buffer.js
+built-ins/TypedArray/prototype/includes/detached-buffer.js
+built-ins/TypedArray/prototype/includes/detached-buffer-tointeger.js
+built-ins/TypedArray/prototype/indexOf/detached-buffer.js
+built-ins/TypedArray/prototype/join/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/join/BigInt/empty-instance-empty-string.js
+built-ins/TypedArray/prototype/join/BigInt/return-abrupt-from-separator-symbol.js
+built-ins/TypedArray/prototype/join/BigInt/return-abrupt-from-separator.js
+built-ins/TypedArray/prototype/join/detached-buffer.js
+built-ins/TypedArray/prototype/keys/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/keys/detached-buffer.js
+built-ins/TypedArray/prototype/lastIndexOf/detached-buffer.js
+built-ins/TypedArray/prototype/length/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/length/BigInt/return-length.js
+built-ins/TypedArray/prototype/length/detached-buffer.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-is-not-callable.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-not-called-on-empty.js
+built-ins/TypedArray/prototype/map/BigInt/callbackfn-returns-abrupt.js
+built-ins/TypedArray/prototype/map/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/map/BigInt/return-new-typedarray-from-empty-length.js
+built-ins/TypedArray/prototype/map/BigInt/return-new-typedarray-from-positive-length.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-custom-ctor-length-throws.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-custom-ctor-throws.js
+built-ins/TypedArray/prototype/map/BigInt/speciesctor-get-species-returns-throws.js
+built-ins/TypedArray/prototype/map/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/map/detached-buffer.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-is-not-callable-throws.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-not-called-on-empty.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-returns-abrupt.js
+built-ins/TypedArray/prototype/reduce/BigInt/callbackfn-this.js
+built-ins/TypedArray/prototype/reduce/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/reduce/BigInt/empty-instance-return-initialvalue.js
+built-ins/TypedArray/prototype/reduce/BigInt/empty-instance-with-no-initialvalue-throws.js
+built-ins/TypedArray/prototype/reduce/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/reduce/detached-buffer.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-is-not-callable-throws.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-not-called-on-empty.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-returns-abrupt.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/callbackfn-this.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/empty-instance-return-initialvalue.js
+built-ins/TypedArray/prototype/reduceRight/BigInt/empty-instance-with-no-initialvalue-throws.js
+built-ins/TypedArray/prototype/reduceRight/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/reduceRight/detached-buffer.js
+built-ins/TypedArray/prototype/reverse/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/reverse/BigInt/preserves-non-numeric-properties.js
+built-ins/TypedArray/prototype/reverse/BigInt/returns-original-object.js
+built-ins/TypedArray/prototype/reverse/detached-buffer.js
+built-ins/TypedArray/prototype/set/BigInt/array-arg-return-abrupt-from-tointeger-offset.js
+built-ins/TypedArray/prototype/set/BigInt/null-tobigint.js
+built-ins/TypedArray/prototype/set/BigInt/number-tobigint.js
+built-ins/TypedArray/prototype/set/BigInt/src-typedarray-not-big-throws.js
+built-ins/TypedArray/prototype/set/BigInt/string-nan-tobigint.js
+built-ins/TypedArray/prototype/set/BigInt/symbol-tobigint.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-negative-integer-offset-throws.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-return-abrupt-from-tointeger-offset-symbol.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-return-abrupt-from-tointeger-offset.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-src-range-greather-than-target-throws-rangeerror.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-srcbuffer-detached-during-tointeger-offset-throws.js
+built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-targetbuffer-detached-during-tointeger-offset-throws.js
+built-ins/TypedArray/prototype/set/BigInt/undefined-tobigint.js
+built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-get-src-value-throws.js
+built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-tointeger-offset-throws.js
+built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-throws.js
+built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type-conversions-sab.js
+built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-other-type-sab.js
+built-ins/TypedArray/prototype/set/typedarray-arg-set-values-diff-buffer-same-type-sab.js
+built-ins/TypedArray/prototype/set/typedarray-arg-set-values-same-buffer-same-type-sab.js
+built-ins/TypedArray/prototype/set/typedarray-arg-srcbuffer-detached-during-tointeger-offset-throws.js
+built-ins/TypedArray/prototype/set/typedarray-arg-targetbuffer-detached-during-tointeger-offset-throws.js
+built-ins/TypedArray/prototype/slice/BigInt/detached-buffer-custom-ctor-other-targettype.js
+built-ins/TypedArray/prototype/slice/BigInt/detached-buffer-custom-ctor-same-targettype.js
+built-ins/TypedArray/prototype/slice/BigInt/detached-buffer-get-ctor.js
+built-ins/TypedArray/prototype/slice/BigInt/detached-buffer-speciesctor-get-species-custom-ctor-throws.js
+built-ins/TypedArray/prototype/slice/BigInt/detached-buffer-zero-count-custom-ctor-other-targettype.js
+built-ins/TypedArray/prototype/slice/BigInt/detached-buffer-zero-count-custom-ctor-same-targettype.js
+built-ins/TypedArray/prototype/slice/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/slice/BigInt/return-abrupt-from-end-symbol.js
+built-ins/TypedArray/prototype/slice/BigInt/return-abrupt-from-end.js
+built-ins/TypedArray/prototype/slice/BigInt/return-abrupt-from-start-symbol.js
+built-ins/TypedArray/prototype/slice/BigInt/return-abrupt-from-start.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-abrupt.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-custom-ctor-length-throws.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-custom-ctor-length.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-custom-ctor-throws.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-returns-throws.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species-use-default-ctor.js
+built-ins/TypedArray/prototype/slice/BigInt/speciesctor-get-species.js
+built-ins/TypedArray/prototype/slice/detached-buffer-custom-ctor-other-targettype.js
+built-ins/TypedArray/prototype/slice/detached-buffer-custom-ctor-same-targettype.js
+built-ins/TypedArray/prototype/slice/detached-buffer-get-ctor.js
+built-ins/TypedArray/prototype/slice/detached-buffer-speciesctor-get-species-custom-ctor-throws.js
+built-ins/TypedArray/prototype/slice/detached-buffer-zero-count-custom-ctor-other-targettype.js
+built-ins/TypedArray/prototype/slice/detached-buffer-zero-count-custom-ctor-same-targettype.js
+built-ins/TypedArray/prototype/slice/detached-buffer.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-not-callable-throws.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-not-called-on-empty.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-returns-abrupt.js
+built-ins/TypedArray/prototype/some/BigInt/callbackfn-this.js
+built-ins/TypedArray/prototype/some/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/some/BigInt/returns-false-if-every-cb-returns-false.js
+built-ins/TypedArray/prototype/some/BigInt/returns-true-if-any-cb-returns-true.js
+built-ins/TypedArray/prototype/some/callbackfn-detachbuffer.js
+built-ins/TypedArray/prototype/some/detached-buffer.js
+built-ins/TypedArray/prototype/sort/BigInt/detached-buffer-comparefn.js
+built-ins/TypedArray/prototype/sort/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/sort/detached-buffer-comparefn-coerce.js
+built-ins/TypedArray/prototype/sort/detached-buffer-comparefn.js
+built-ins/TypedArray/prototype/sort/detached-buffer.js
+built-ins/TypedArray/prototype/sort/sort-tonumber.js
+built-ins/TypedArray/prototype/subarray/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin-symbol.js
+built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-begin.js
+built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end-symbol.js
+built-ins/TypedArray/prototype/subarray/BigInt/return-abrupt-from-end.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-abrupt.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-custom-ctor-throws.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-returns-throws.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species-use-default-ctor.js
+built-ins/TypedArray/prototype/subarray/BigInt/speciesctor-get-species.js
+built-ins/TypedArray/prototype/subarray/detached-buffer.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/toLocaleString/BigInt/empty-instance-returns-empty-string.js
+built-ins/TypedArray/prototype/toLocaleString/detached-buffer.js
+built-ins/TypedArray/prototype/toLocaleString/get-length-uses-internal-arraylength.js
+built-ins/TypedArray/prototype/toLocaleString/return-result.js
+built-ins/TypedArray/prototype/toString/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/toString/detached-buffer.js
+built-ins/TypedArray/prototype/values/BigInt/detached-buffer.js
+built-ins/TypedArray/prototype/values/detached-buffer.js
+built-ins/TypedArrayConstructors/BigInt64Array/BYTES_PER_ELEMENT.js
+built-ins/TypedArrayConstructors/BigInt64Array/constructor.js
+built-ins/TypedArrayConstructors/BigInt64Array/length.js
+built-ins/TypedArrayConstructors/BigInt64Array/name.js
+built-ins/TypedArrayConstructors/BigInt64Array/prop-desc.js
+built-ins/TypedArrayConstructors/BigInt64Array/proto.js
+built-ins/TypedArrayConstructors/BigInt64Array/prototype.js
+built-ins/TypedArrayConstructors/BigInt64Array/prototype/BYTES_PER_ELEMENT.js
+built-ins/TypedArrayConstructors/BigInt64Array/prototype/constructor.js
+built-ins/TypedArrayConstructors/BigInt64Array/prototype/not-typedarray-object.js
+built-ins/TypedArrayConstructors/BigInt64Array/prototype/proto.js
+built-ins/TypedArrayConstructors/BigUint64Array/BYTES_PER_ELEMENT.js
+built-ins/TypedArrayConstructors/BigUint64Array/constructor.js
+built-ins/TypedArrayConstructors/BigUint64Array/length.js
+built-ins/TypedArrayConstructors/BigUint64Array/name.js
+built-ins/TypedArrayConstructors/BigUint64Array/prop-desc.js
+built-ins/TypedArrayConstructors/BigUint64Array/proto.js
+built-ins/TypedArrayConstructors/BigUint64Array/prototype.js
+built-ins/TypedArrayConstructors/BigUint64Array/prototype/BYTES_PER_ELEMENT.js
+built-ins/TypedArrayConstructors/BigUint64Array/prototype/constructor.js
+built-ins/TypedArrayConstructors/BigUint64Array/prototype/not-typedarray-object.js
+built-ins/TypedArrayConstructors/BigUint64Array/prototype/proto.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/bufferbyteoffset-throws-from-modulo-element-size-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/bufferbyteoffset-throws-from-modulo-element-size.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-is-negative-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-is-negative-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-is-negative-zero-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-is-negative-zero.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-is-symbol-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-is-symbol-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-throws-from-modulo-element-size-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-throws-from-modulo-element-size.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-to-number-detachbuffer.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-to-number-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/byteoffset-to-number-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/custom-proto-access-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/custom-proto-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-length-and-offset-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-length-and-offset.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-length-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-length.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-negative-length-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-negative-length.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-offset-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/defined-offset.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/detachedbuffer.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/excessive-length-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/excessive-length-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/excessive-offset-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/excessive-offset-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/invoked-with-undefined-newtarget-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/invoked-with-undefined-newtarget.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/is-referenced-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/is-referenced.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/length-access-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/length-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/length-is-symbol-throws-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/length-is-symbol-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/length-to-number-detachbuffer.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/new-instance-extensibility-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/new-instance-extensibility.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/proto-from-ctor-realm-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/returns-new-instance-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/returns-new-instance.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/toindex-bytelength-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/toindex-bytelength.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/toindex-byteoffset-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/toindex-byteoffset.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/typedarray-backed-by-sharedarraybuffer.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/use-custom-proto-if-object-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/use-custom-proto-if-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/use-default-proto-if-custom-proto-is-not-object-sab.js
+built-ins/TypedArrayConstructors/ctors-bigint/buffer-arg/use-default-proto-if-custom-proto-is-not-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/custom-proto-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/is-infinity-throws-rangeerror.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/is-negative-integer-throws-rangeerror.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/is-symbol-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/new-instance-extensibility.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/returns-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/toindex-length.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/undefined-newtarget-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/use-custom-proto-if-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/length-arg/use-default-proto-if-custom-proto-is-not-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/no-args/custom-proto-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/no-args/new-instance-extensibility.js
+built-ins/TypedArrayConstructors/ctors-bigint/no-args/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors-bigint/no-args/returns-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/no-args/undefined-newtarget-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/no-args/use-custom-proto-if-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/no-args/use-default-proto-if-custom-proto-is-not-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/custom-proto-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/iterating-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/iterator-not-callable-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/iterator-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/length-excessive-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/length-is-symbol-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/length-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/null-tobigint.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/number-tobigint.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/string-nan-tobigint.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/symbol-tobigint.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/throws-setting-symbol-property.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/undefined-newtarget-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/undefined-tobigint.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/use-custom-proto-if-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/object-arg/use-default-proto-if-custom-proto-is-not-object.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/custom-proto-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/detached-when-species-retrieved-different-type.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/detached-when-species-retrieved-same-type.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/new-instance-extensibility.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-custom-species-proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-custom-species.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-not-object-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-species-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-species-not-ctor-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-species-null.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-species-prototype-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-buffer-ctor-species-undefined.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/other-ctor-returns-new-typedarray.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-access-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-species-custom-proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-species-custom.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-species-not-ctor.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-species-null.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-species-prototype-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-species-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-species-undefined.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-buffer-ctor-value-not-obj-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/same-ctor-returns-new-cloned-typedarray.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/src-typedarray-not-big-throws.js
+built-ins/TypedArrayConstructors/ctors-bigint/typedarray-arg/undefined-newtarget-throws.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/bufferbyteoffset-throws-from-modulo-element-size-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/byteoffset-is-negative-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/byteoffset-is-negative-zero-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/byteoffset-is-symbol-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/byteoffset-throws-from-modulo-element-size-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/byteoffset-to-number-detachbuffer.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/byteoffset-to-number-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/custom-proto-access-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/defined-length-and-offset-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/defined-length-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/defined-negative-length-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/defined-offset-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/detachedbuffer.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/excessive-length-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/excessive-offset-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/invoked-with-undefined-newtarget-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/is-referenced-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/length-access-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/length-is-symbol-throws-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/length-to-number-detachbuffer.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/new-instance-extensibility-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/proto-from-ctor-realm-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/returns-new-instance-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/toindex-bytelength-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/toindex-byteoffset-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/typedarray-backed-by-sharedarraybuffer.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/use-custom-proto-if-object-sab.js
+built-ins/TypedArrayConstructors/ctors/buffer-arg/use-default-proto-if-custom-proto-is-not-object-sab.js
+built-ins/TypedArrayConstructors/ctors/length-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors/no-args/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors/object-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors/typedarray-arg/detached-when-species-retrieved-different-type.js
+built-ins/TypedArrayConstructors/ctors/typedarray-arg/detached-when-species-retrieved-same-type.js
+built-ins/TypedArrayConstructors/ctors/typedarray-arg/other-ctor-buffer-ctor-custom-species-proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors/typedarray-arg/proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors/typedarray-arg/same-ctor-buffer-ctor-species-custom-proto-from-ctor-realm.js
+built-ins/TypedArrayConstructors/ctors/typedarray-arg/src-typedarray-big-throws.js
+built-ins/TypedArrayConstructors/from/BigInt/arylk-get-length-error.js
+built-ins/TypedArrayConstructors/from/BigInt/arylk-to-length-error.js
+built-ins/TypedArrayConstructors/from/BigInt/custom-ctor-does-not-instantiate-ta-throws.js
+built-ins/TypedArrayConstructors/from/BigInt/custom-ctor.js
+built-ins/TypedArrayConstructors/from/BigInt/inherited.js
+built-ins/TypedArrayConstructors/from/BigInt/invoked-as-func.js
+built-ins/TypedArrayConstructors/from/BigInt/iter-access-error.js
+built-ins/TypedArrayConstructors/from/BigInt/iter-invoke-error.js
+built-ins/TypedArrayConstructors/from/BigInt/iter-next-error.js
+built-ins/TypedArrayConstructors/from/BigInt/iter-next-value-error.js
+built-ins/TypedArrayConstructors/from/BigInt/mapfn-is-not-callable.js
+built-ins/TypedArrayConstructors/from/BigInt/new-instance-empty.js
+built-ins/TypedArrayConstructors/from/BigInt/property-abrupt-completion.js
+built-ins/TypedArrayConstructors/from/BigInt/source-value-is-symbol-throws.js
+built-ins/TypedArrayConstructors/from/BigInt/this-is-not-constructor.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/key-is-numericindex-desc-configurable.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/key-is-numericindex.js
+built-ins/TypedArrayConstructors/internals/DefineOwnProperty/tonumber-value-detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/infinity-detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/key-is-not-canonical-index.js
+built-ins/TypedArrayConstructors/internals/Get/BigInt/key-is-not-numeric-index-get-throws.js
+built-ins/TypedArrayConstructors/internals/Get/detached-buffer-key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/Get/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/Get/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/Get/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Get/indexed-value-sab.js
+built-ins/TypedArrayConstructors/internals/Get/infinity-detached-buffer.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/BigInt/enumerate-detached-buffer.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/detached-buffer-key-is-not-number.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/enumerate-detached-buffer.js
+built-ins/TypedArrayConstructors/internals/GetOwnProperty/index-prop-desc.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/abrupt-from-ordinary-has-parent-hasproperty.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/inherited-property.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/key-is-greater-than-last-index.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/key-is-lower-than-zero.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/key-is-minus-zero.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/key-is-not-integer.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/HasProperty/BigInt/key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/HasProperty/detached-buffer-key-is-not-number.js
+built-ins/TypedArrayConstructors/internals/HasProperty/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/HasProperty/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/HasProperty/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/OwnPropertyKeys/BigInt/not-enumerable-keys.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/key-is-not-numeric-index-set-throws.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/null-tobigint.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/number-tobigint.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/string-nan-tobigint.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/symbol-tobigint.js
+built-ins/TypedArrayConstructors/internals/Set/BigInt/undefined-tobigint.js
+built-ins/TypedArrayConstructors/internals/Set/detached-buffer-key-is-not-numeric-index.js
+built-ins/TypedArrayConstructors/internals/Set/detached-buffer-key-is-symbol.js
+built-ins/TypedArrayConstructors/internals/Set/detached-buffer-realm.js
+built-ins/TypedArrayConstructors/internals/Set/detached-buffer.js
+built-ins/TypedArrayConstructors/internals/Set/tonumber-value-detached-buffer.js
+built-ins/TypedArrayConstructors/of/BigInt/argument-is-symbol-throws.js
+built-ins/TypedArrayConstructors/of/BigInt/inherited.js
+built-ins/TypedArrayConstructors/of/BigInt/invoked-as-func.js
+built-ins/TypedArrayConstructors/of/BigInt/new-instance-empty.js
+built-ins/TypedArrayConstructors/prototype/Symbol.toStringTag/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/bigint-Symbol.iterator.js
+built-ins/TypedArrayConstructors/prototype/buffer/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/byteLength/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/byteOffset/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/copyWithin/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/entries/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/every/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/fill/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/filter/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/find/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/findIndex/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/forEach/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/indexOf/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/join/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/keys/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/lastIndexOf/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/length/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/map/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/reduce/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/reduceRight/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/reverse/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/set/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/slice/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/some/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/sort/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/subarray/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/toLocaleString/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/toString/bigint-inherited.js
+built-ins/TypedArrayConstructors/prototype/values/bigint-inherited.js
+built-ins/WeakMap/proto-from-ctor-realm.js
+built-ins/WeakRef/constructor.js
+built-ins/WeakRef/instance-extensible.js
+built-ins/WeakRef/length.js
+built-ins/WeakRef/name.js
+built-ins/WeakRef/newtarget-prototype-is-not-object.js
+built-ins/WeakRef/prop-desc.js
+built-ins/WeakRef/proto-from-ctor-realm.js
+built-ins/WeakRef/proto.js
+built-ins/WeakRef/prototype-from-newtarget-abrupt.js
+built-ins/WeakRef/prototype-from-newtarget-custom.js
+built-ins/WeakRef/prototype-from-newtarget.js
+built-ins/WeakRef/prototype/Symbol.toStringTag.js
+built-ins/WeakRef/prototype/constructor.js
+built-ins/WeakRef/prototype/deref/custom-this.js
+built-ins/WeakRef/prototype/deref/gc-cleanup-not-prevented-with-wr-deref.js
+built-ins/WeakRef/prototype/deref/length.js
+built-ins/WeakRef/prototype/deref/name.js
+built-ins/WeakRef/prototype/deref/prop-desc.js
+built-ins/WeakRef/prototype/deref/return-target.js
+built-ins/WeakRef/prototype/deref/this-does-not-have-internal-target-throws.js
+built-ins/WeakRef/prototype/deref/this-not-object-throws.js
+built-ins/WeakRef/prototype/prop-desc.js
+built-ins/WeakRef/prototype/proto.js
+built-ins/WeakRef/returns-new-object-from-constructor.js
+built-ins/WeakRef/target-not-object-throws.js
+built-ins/WeakRef/undefined-newtarget-throws.js
+built-ins/WeakSet/proto-from-ctor-realm.js
+built-ins/eval/private-identifiers-not-empty.js
+built-ins/global/S10.2.3_A1.3_T1.js
+built-ins/global/S10.2.3_A1.3_T2.js
+built-ins/global/S10.2.3_A1.3_T3.js
+built-ins/global/S10.2.3_A1.3_T4.js
+built-ins/global/S10.2.3_A2.3_T1.js
+built-ins/global/S10.2.3_A2.3_T2.js
+built-ins/global/S10.2.3_A2.3_T3.js
+built-ins/global/S10.2.3_A2.3_T4.js
+built-ins/undefined/S15.1.1.3_A1.js
+intl402/Array/prototype/toLocaleString/calls-toLocaleString-number-elements.js
+intl402/BigInt/prototype/toLocaleString/builtin.js
+intl402/BigInt/prototype/toLocaleString/length.js
+intl402/BigInt/prototype/toLocaleString/name.js
+intl402/BigInt/prototype/toLocaleString/prop-desc.js
+intl402/Collator/builtin.js
+intl402/Collator/constructor-options-throwing-getters.js
+intl402/Collator/default-options-object-prototype.js
+intl402/Collator/ignore-invalid-unicode-ext-values.js
+intl402/Collator/instance-proto-and-extensible.js
+intl402/Collator/legacy-regexp-statics-not-modified.js
+intl402/Collator/length.js
+intl402/Collator/missing-unicode-ext-value-defaults-to-true.js
+intl402/Collator/name.js
+intl402/Collator/numeric-and-caseFirst.js
+intl402/Collator/prop-desc.js
+intl402/Collator/proto-from-ctor-realm.js
+intl402/Collator/prototype/builtin.js
+intl402/Collator/prototype/compare/bound-to-collator-instance.js
+intl402/Collator/prototype/compare/builtin.js
+intl402/Collator/prototype/compare/canonically-equivalent-strings.js
+intl402/Collator/prototype/compare/compare-function-builtin.js
+intl402/Collator/prototype/compare/compare-function-length.js
+intl402/Collator/prototype/compare/compare-function-name.js
+intl402/Collator/prototype/compare/length.js
+intl402/Collator/prototype/compare/name.js
+intl402/Collator/prototype/compare/non-normative-basic.js
+intl402/Collator/prototype/compare/non-normative-phonebook.js
+intl402/Collator/prototype/compare/non-normative-sensitivity.js
+intl402/Collator/prototype/compare/prop-desc.js
+intl402/Collator/prototype/constructor/prop-desc.js
+intl402/Collator/prototype/constructor/value.js
+intl402/Collator/prototype/prop-desc.js
+intl402/Collator/prototype/resolvedOptions/basic.js
+intl402/Collator/prototype/resolvedOptions/builtin.js
+intl402/Collator/prototype/resolvedOptions/length.js
+intl402/Collator/prototype/resolvedOptions/name.js
+intl402/Collator/prototype/resolvedOptions/order.js
+intl402/Collator/prototype/resolvedOptions/prop-desc.js
+intl402/Collator/prototype/this-value-not-collator.js
+intl402/Collator/prototype/toStringTag/toString-changed-tag.js
+intl402/Collator/prototype/toStringTag/toString-removed-tag.js
+intl402/Collator/prototype/toStringTag/toString.js
+intl402/Collator/prototype/toStringTag/toStringTag.js
+intl402/Collator/subclassing.js
+intl402/Collator/supportedLocalesOf/basic.js
+intl402/Collator/supportedLocalesOf/builtin.js
+intl402/Collator/supportedLocalesOf/length.js
+intl402/Collator/supportedLocalesOf/name.js
+intl402/Collator/supportedLocalesOf/prop-desc.js
+intl402/Collator/supportedLocalesOf/taint-Object-prototype.js
+intl402/Collator/taint-Object-prototype.js
+intl402/Collator/test-option-ignorePunctuation.js
+intl402/Collator/test-option-localeMatcher.js
+intl402/Collator/test-option-numeric-and-caseFirst.js
+intl402/Collator/test-option-sensitivity.js
+intl402/Collator/test-option-usage.js
+intl402/Collator/this-value-ignored.js
+intl402/Collator/unicode-ext-seq-in-private-tag.js
+intl402/Collator/unicode-ext-seq-with-attribute.js
+intl402/Collator/unicode-ext-value-collation.js
+intl402/Collator/usage-de.js
+intl402/Date/prototype/returns-same-results-as-DateTimeFormat.js
+intl402/Date/prototype/taint-Intl-DateTimeFormat.js
+intl402/Date/prototype/this-value-invalid-date.js
+intl402/Date/prototype/throws-same-exceptions-as-DateTimeFormat.js
+intl402/Date/prototype/toLocaleString/default-options-object-prototype.js
+intl402/DateTimeFormat/casing-numbering-system-calendar-options.js
+intl402/DateTimeFormat/constructor-calendar-numberingSystem-order.js
+intl402/DateTimeFormat/constructor-default-value.js
+intl402/DateTimeFormat/constructor-options-dateStyle-invalid.js
+intl402/DateTimeFormat/constructor-options-dateStyle-valid.js
+intl402/DateTimeFormat/constructor-options-dayPeriod-invalid.js
+intl402/DateTimeFormat/constructor-options-dayPeriod-valid.js
+intl402/DateTimeFormat/constructor-options-fractionalSecondDigits-invalid.js
+intl402/DateTimeFormat/constructor-options-fractionalSecondDigits-valid.js
+intl402/DateTimeFormat/constructor-options-order-dayPeriod.js
+intl402/DateTimeFormat/constructor-options-order-fractionalSecondDigits.js
+intl402/DateTimeFormat/constructor-options-order-timedate-style.js
+intl402/DateTimeFormat/constructor-options-order.js
+intl402/DateTimeFormat/constructor-options-throwing-getters.js
+intl402/DateTimeFormat/constructor-options-timeStyle-invalid.js
+intl402/DateTimeFormat/constructor-options-timeStyle-valid.js
+intl402/DateTimeFormat/constructor-options-toobject.js
+intl402/DateTimeFormat/date-time-options.js
+intl402/DateTimeFormat/default-options-object-prototype.js
+intl402/DateTimeFormat/ignore-invalid-unicode-ext-values.js
+intl402/DateTimeFormat/instance-proto-and-extensible.js
+intl402/DateTimeFormat/legacy-regexp-statics-not-modified.js
+intl402/DateTimeFormat/numbering-system-calendar-options.js
+intl402/DateTimeFormat/proto-from-ctor-realm.js
+intl402/DateTimeFormat/prototype/format/bound-to-datetimeformat-instance.js
+intl402/DateTimeFormat/prototype/format/date-constructor-not-called.js
+intl402/DateTimeFormat/prototype/format/dayPeriod-long-en.js
+intl402/DateTimeFormat/prototype/format/dayPeriod-narrow-en.js
+intl402/DateTimeFormat/prototype/format/dayPeriod-short-en.js
+intl402/DateTimeFormat/prototype/format/format-function-builtin.js
+intl402/DateTimeFormat/prototype/format/format-function-length.js
+intl402/DateTimeFormat/prototype/format/format-function-name.js
+intl402/DateTimeFormat/prototype/format/fractionalSecondDigits.js
+intl402/DateTimeFormat/prototype/format/proleptic-gregorian-calendar.js
+intl402/DateTimeFormat/prototype/format/related-year-zh.js
+intl402/DateTimeFormat/prototype/format/taint-Object-prototype.js
+intl402/DateTimeFormat/prototype/format/throws-value-non-finite.js
+intl402/DateTimeFormat/prototype/format/time-clip-near-time-boundaries.js
+intl402/DateTimeFormat/prototype/format/time-clip-to-integer.js
+intl402/DateTimeFormat/prototype/format/timedatestyle-en.js
+intl402/DateTimeFormat/prototype/formatRange/argument-date-string.js
+intl402/DateTimeFormat/prototype/formatRange/argument-near-time-boundaries.js
+intl402/DateTimeFormat/prototype/formatRange/argument-to-integer.js
+intl402/DateTimeFormat/prototype/formatRange/argument-tonumber-throws.js
+intl402/DateTimeFormat/prototype/formatRange/date-is-infinity-throws.js
+intl402/DateTimeFormat/prototype/formatRange/date-is-nan-throws.js
+intl402/DateTimeFormat/prototype/formatRange/date-undefined-throws.js
+intl402/DateTimeFormat/prototype/formatRange/date-x-greater-than-y-throws.js
+intl402/DateTimeFormat/prototype/formatRange/en-US.js
+intl402/DateTimeFormat/prototype/formatRange/fractionalSecondDigits.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/argument-date-string.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/argument-near-time-boundaries.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/argument-to-integer.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/argument-tonumber-throws.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/date-is-infinity-throws.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/date-is-nan-throws.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/date-undefined-throws.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/date-x-greater-than-y-throws.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/en-US.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/fractionalSecondDigits.js
+intl402/DateTimeFormat/prototype/formatRangeToParts/pattern-on-calendar.js
+intl402/DateTimeFormat/prototype/formatToParts/date-constructor-not-called.js
+intl402/DateTimeFormat/prototype/formatToParts/date-is-infinity-throws.js
+intl402/DateTimeFormat/prototype/formatToParts/date-is-nan-throws.js
+intl402/DateTimeFormat/prototype/formatToParts/dayPeriod-long-en.js
+intl402/DateTimeFormat/prototype/formatToParts/dayPeriod-narrow-en.js
+intl402/DateTimeFormat/prototype/formatToParts/dayPeriod-short-en.js
+intl402/DateTimeFormat/prototype/formatToParts/fractionalSecondDigits.js
+intl402/DateTimeFormat/prototype/formatToParts/main.js
+intl402/DateTimeFormat/prototype/formatToParts/pattern-on-calendar.js
+intl402/DateTimeFormat/prototype/formatToParts/related-year-zh.js
+intl402/DateTimeFormat/prototype/formatToParts/related-year.js
+intl402/DateTimeFormat/prototype/formatToParts/return-abrupt-tonumber-date.js
+intl402/DateTimeFormat/prototype/formatToParts/time-clip-near-time-boundaries.js
+intl402/DateTimeFormat/prototype/formatToParts/time-clip-to-integer.js
+intl402/DateTimeFormat/prototype/resolvedOptions/basic.js
+intl402/DateTimeFormat/prototype/resolvedOptions/hourCycle-dateStyle.js
+intl402/DateTimeFormat/prototype/resolvedOptions/hourCycle-default.js
+intl402/DateTimeFormat/prototype/resolvedOptions/hourCycle-timeStyle.js
+intl402/DateTimeFormat/prototype/resolvedOptions/hourCycle.js
+intl402/DateTimeFormat/prototype/resolvedOptions/order-dayPeriod.js
+intl402/DateTimeFormat/prototype/resolvedOptions/order-fractionalSecondDigits.js
+intl402/DateTimeFormat/prototype/resolvedOptions/order-style.js
+intl402/DateTimeFormat/prototype/resolvedOptions/order.js
+intl402/DateTimeFormat/prototype/resolvedOptions/resolved-locale-with-hc-unicode.js
+intl402/DateTimeFormat/prototype/toStringTag/toString-changed-tag.js
+intl402/DateTimeFormat/prototype/toStringTag/toString-removed-tag.js
+intl402/DateTimeFormat/prototype/toStringTag/toString.js
+intl402/DateTimeFormat/required-date-time-formats.js
+intl402/DateTimeFormat/subclassing.js
+intl402/DateTimeFormat/supportedLocalesOf/basic.js
+intl402/DateTimeFormat/supportedLocalesOf/taint-Object-prototype.js
+intl402/DateTimeFormat/taint-Object-prototype-date-time-components.js
+intl402/DateTimeFormat/taint-Object-prototype-dayPeriod.js
+intl402/DateTimeFormat/taint-Object-prototype-fractionalSecondDigits.js
+intl402/DateTimeFormat/taint-Object-prototype.js
+intl402/DateTimeFormat/test-option-date-time-components.js
+intl402/DateTimeFormat/test-option-formatMatcher.js
+intl402/DateTimeFormat/test-option-hour12.js
+intl402/DateTimeFormat/test-option-localeMatcher.js
+intl402/DateTimeFormat/this-value-ignored.js
+intl402/DateTimeFormat/timezone-canonicalized.js
+intl402/DateTimeFormat/timezone-invalid.js
+intl402/DateTimeFormat/timezone-utc.js
+intl402/DisplayNames/ctor-custom-get-prototype-poison-throws.js
+intl402/DisplayNames/ctor-custom-prototype.js
+intl402/DisplayNames/ctor-default-prototype.js
+intl402/DisplayNames/instance-extensible.js
+intl402/DisplayNames/length.js
+intl402/DisplayNames/locales-length-poison-throws.js
+intl402/DisplayNames/locales-length-tolength-throws.js
+intl402/DisplayNames/locales-symbol-length.js
+intl402/DisplayNames/name.js
+intl402/DisplayNames/options-fallback-abrupt-throws.js
+intl402/DisplayNames/options-fallback-invalid-throws.js
+intl402/DisplayNames/options-fallback-toString-abrupt-throws.js
+intl402/DisplayNames/options-fallback-valid.js
+intl402/DisplayNames/options-localeMatcher-abrupt-throws.js
+intl402/DisplayNames/options-localeMatcher-invalid-throws.js
+intl402/DisplayNames/options-localeMatcher-toString-abrupt-throws.js
+intl402/DisplayNames/options-localeMatcher-valid.js
+intl402/DisplayNames/options-random-properties-unchecked.js
+intl402/DisplayNames/options-style-abrupt-throws.js
+intl402/DisplayNames/options-style-invalid-throws.js
+intl402/DisplayNames/options-style-toString-abrupt-throws.js
+intl402/DisplayNames/options-style-valid.js
+intl402/DisplayNames/options-type-abrupt-throws.js
+intl402/DisplayNames/options-type-invalid-throws.js
+intl402/DisplayNames/options-type-toString-abrupt-throws.js
+intl402/DisplayNames/options-type-valid.js
+intl402/DisplayNames/prop-desc.js
+intl402/DisplayNames/proto-from-ctor-realm.js
+intl402/DisplayNames/proto.js
+intl402/DisplayNames/prototype/Symbol.toStringTag.js
+intl402/DisplayNames/prototype/prop-desc.js
+intl402/DisplayNames/prototype/resolvedOptions/default-option-values.js
+intl402/DisplayNames/prototype/resolvedOptions/length.js
+intl402/DisplayNames/prototype/resolvedOptions/name.js
+intl402/DisplayNames/prototype/resolvedOptions/option-fallback.js
+intl402/DisplayNames/prototype/resolvedOptions/option-style.js
+intl402/DisplayNames/prototype/resolvedOptions/option-type.js
+intl402/DisplayNames/prototype/resolvedOptions/prop-desc.js
+intl402/DisplayNames/prototype/resolvedOptions/return-object.js
+intl402/DisplayNames/prototype/resolvedOptions/this-not-object-throws.js
+intl402/DisplayNames/prototype/resolvedOptions/this-object-lacks-internal-throws.js
+intl402/Intl/builtin.js
+intl402/Intl/getCanonicalLocales/canonicalized-tags.js
+intl402/Intl/getCanonicalLocales/complex-language-subtag-replacement.js
+intl402/Intl/getCanonicalLocales/complex-region-subtag-replacement.js
+intl402/Intl/getCanonicalLocales/grandfathered.js
+intl402/Intl/getCanonicalLocales/preferred-grandfathered.js
+intl402/Intl/getCanonicalLocales/preferred-variant.js
+intl402/Intl/getCanonicalLocales/transformed-ext-canonical.js
+intl402/Intl/getCanonicalLocales/transformed-ext-invalid.js
+intl402/Intl/getCanonicalLocales/unicode-ext-canonicalize-calendar.js
+intl402/Intl/getCanonicalLocales/unicode-ext-canonicalize-col-strength.js
+intl402/Intl/getCanonicalLocales/unicode-ext-canonicalize-measurement-system.js
+intl402/Intl/getCanonicalLocales/unicode-ext-canonicalize-region.js
+intl402/Intl/getCanonicalLocales/unicode-ext-canonicalize-subdivision.js
+intl402/Intl/getCanonicalLocales/unicode-ext-canonicalize-timezone.js
+intl402/Intl/getCanonicalLocales/unicode-ext-canonicalize-yes-to-true.js
+intl402/ListFormat/constructor/constructor/locales-invalid.js
+intl402/ListFormat/constructor/constructor/locales-valid.js
+intl402/ListFormat/constructor/constructor/newtarget-undefined.js
+intl402/ListFormat/constructor/constructor/options-invalid.js
+intl402/ListFormat/constructor/constructor/options-localeMatcher-invalid.js
+intl402/ListFormat/constructor/constructor/options-order.js
+intl402/ListFormat/constructor/constructor/options-style-invalid.js
+intl402/ListFormat/constructor/constructor/options-style-valid.js
+intl402/ListFormat/constructor/constructor/options-throwing-getters.js
+intl402/ListFormat/constructor/constructor/options-toobject-prototype.js
+intl402/ListFormat/constructor/constructor/options-toobject.js
+intl402/ListFormat/constructor/constructor/options-type-invalid.js
+intl402/ListFormat/constructor/constructor/options-type-valid.js
+intl402/ListFormat/constructor/constructor/options-undefined.js
+intl402/ListFormat/constructor/constructor/proto-from-ctor-realm.js
+intl402/ListFormat/constructor/constructor/subclassing.js
+intl402/ListFormat/constructor/length.js
+intl402/ListFormat/constructor/name.js
+intl402/ListFormat/constructor/prop-desc.js
+intl402/ListFormat/constructor/prototype.js
+intl402/ListFormat/constructor/supportedLocalesOf/basic.js
+intl402/ListFormat/constructor/supportedLocalesOf/branding.js
+intl402/ListFormat/constructor/supportedLocalesOf/length.js
+intl402/ListFormat/constructor/supportedLocalesOf/locales-invalid.js
+intl402/ListFormat/constructor/supportedLocalesOf/name.js
+intl402/ListFormat/constructor/supportedLocalesOf/options-localeMatcher-invalid.js
+intl402/ListFormat/constructor/supportedLocalesOf/options-null.js
+intl402/ListFormat/constructor/supportedLocalesOf/options-toobject.js
+intl402/ListFormat/constructor/supportedLocalesOf/options-undefined.js
+intl402/ListFormat/constructor/supportedLocalesOf/prop-desc.js
+intl402/ListFormat/constructor/supportedLocalesOf/result-type.js
+intl402/ListFormat/instance/extensibility.js
+intl402/ListFormat/instance/prototype.js
+intl402/ListFormat/prototype/constructor/prop-desc.js
+intl402/ListFormat/prototype/format/branding.js
+intl402/ListFormat/prototype/format/en-us-default.js
+intl402/ListFormat/prototype/format/en-us-disjunction.js
+intl402/ListFormat/prototype/format/en-us-narrow.js
+intl402/ListFormat/prototype/format/en-us-short.js
+intl402/ListFormat/prototype/format/en-us-unit.js
+intl402/ListFormat/prototype/format/es-es-long.js
+intl402/ListFormat/prototype/format/es-es-narrow.js
+intl402/ListFormat/prototype/format/es-es-short.js
+intl402/ListFormat/prototype/format/iterable-getiterator-throw.js
+intl402/ListFormat/prototype/format/iterable-invalid.js
+intl402/ListFormat/prototype/format/iterable-iteratorclose.js
+intl402/ListFormat/prototype/format/iterable-iteratorstep-throw.js
+intl402/ListFormat/prototype/format/iterable-iteratorvalue-throw.js
+intl402/ListFormat/prototype/format/iterable-undefined.js
+intl402/ListFormat/prototype/format/iterable.js
+intl402/ListFormat/prototype/format/length.js
+intl402/ListFormat/prototype/format/name.js
+intl402/ListFormat/prototype/format/prop-desc.js
+intl402/ListFormat/prototype/formatToParts/branding.js
+intl402/ListFormat/prototype/formatToParts/en-us-default.js
+intl402/ListFormat/prototype/formatToParts/en-us-disjunction.js
+intl402/ListFormat/prototype/formatToParts/en-us-narrow.js
+intl402/ListFormat/prototype/formatToParts/en-us-short.js
+intl402/ListFormat/prototype/formatToParts/en-us-unit.js
+intl402/ListFormat/prototype/formatToParts/es-es-long.js
+intl402/ListFormat/prototype/formatToParts/es-es-narrow.js
+intl402/ListFormat/prototype/formatToParts/es-es-short.js
+intl402/ListFormat/prototype/formatToParts/iterable-getiterator-throw.js
+intl402/ListFormat/prototype/formatToParts/iterable-invalid.js
+intl402/ListFormat/prototype/formatToParts/iterable-iteratorclose.js
+intl402/ListFormat/prototype/formatToParts/iterable-iteratorstep-throw.js
+intl402/ListFormat/prototype/formatToParts/iterable-iteratorvalue-throw.js
+intl402/ListFormat/prototype/formatToParts/iterable-undefined.js
+intl402/ListFormat/prototype/formatToParts/iterable.js
+intl402/ListFormat/prototype/formatToParts/length.js
+intl402/ListFormat/prototype/formatToParts/name.js
+intl402/ListFormat/prototype/formatToParts/prop-desc.js
+intl402/ListFormat/prototype/prop-desc.js
+intl402/ListFormat/prototype/resolvedOptions/branding.js
+intl402/ListFormat/prototype/resolvedOptions/caching.js
+intl402/ListFormat/prototype/resolvedOptions/length.js
+intl402/ListFormat/prototype/resolvedOptions/name.js
+intl402/ListFormat/prototype/resolvedOptions/order.js
+intl402/ListFormat/prototype/resolvedOptions/prop-desc.js
+intl402/ListFormat/prototype/resolvedOptions/type.js
+intl402/ListFormat/prototype/toStringTag/toString.js
+intl402/ListFormat/prototype/toStringTag/toStringTag.js
+intl402/Locale/constructor-apply-options-canonicalizes-twice.js
+intl402/Locale/constructor-non-iana-canon.js
+intl402/Locale/constructor-options-canonicalized.js
+intl402/Locale/constructor-options-region-valid.js
+intl402/Locale/likely-subtags-grandfathered.js
+intl402/Locale/likely-subtags.js
+intl402/Locale/proto-from-ctor-realm.js
+intl402/Locale/prototype/minimize/removing-likely-subtags-first-adds-likely-subtags.js
+intl402/Number/prototype/toLocaleString/returns-same-results-as-NumberFormat.js
+intl402/Number/prototype/toLocaleString/taint-Intl-NumberFormat.js
+intl402/Number/prototype/toLocaleString/this-number-value.js
+intl402/NumberFormat/constructor-unit.js
+intl402/NumberFormat/currency-digits.js
+intl402/NumberFormat/dft-currency-mnfd-range-check-mxfd.js
+intl402/NumberFormat/ignore-invalid-unicode-ext-values.js
+intl402/NumberFormat/proto-from-ctor-realm.js
+intl402/NumberFormat/prototype/format/bound-to-numberformat-instance.js
+intl402/NumberFormat/prototype/format/default-value.js
+intl402/NumberFormat/prototype/format/engineering-scientific-de-DE.js
+intl402/NumberFormat/prototype/format/engineering-scientific-en-US.js
+intl402/NumberFormat/prototype/format/engineering-scientific-ja-JP.js
+intl402/NumberFormat/prototype/format/engineering-scientific-ko-KR.js
+intl402/NumberFormat/prototype/format/engineering-scientific-zh-TW.js
+intl402/NumberFormat/prototype/format/format-fraction-digits-precision.js
+intl402/NumberFormat/prototype/format/format-fraction-digits.js
+intl402/NumberFormat/prototype/format/format-negative-numbers.js
+intl402/NumberFormat/prototype/format/format-non-finite-numbers.js
+intl402/NumberFormat/prototype/format/format-significant-digits-precision.js
+intl402/NumberFormat/prototype/format/format-significant-digits.js
+intl402/NumberFormat/prototype/format/notation-compact-de-DE.js
+intl402/NumberFormat/prototype/format/notation-compact-en-US.js
+intl402/NumberFormat/prototype/format/notation-compact-ja-JP.js
+intl402/NumberFormat/prototype/format/notation-compact-ko-KR.js
+intl402/NumberFormat/prototype/format/notation-compact-zh-TW.js
+intl402/NumberFormat/prototype/format/numbering-systems.js
+intl402/NumberFormat/prototype/format/percent-formatter.js
+intl402/NumberFormat/prototype/format/signDisplay-currency-de-DE.js
+intl402/NumberFormat/prototype/format/signDisplay-currency-en-US.js
+intl402/NumberFormat/prototype/format/signDisplay-currency-ja-JP.js
+intl402/NumberFormat/prototype/format/signDisplay-currency-ko-KR.js
+intl402/NumberFormat/prototype/format/signDisplay-currency-zh-TW.js
+intl402/NumberFormat/prototype/format/signDisplay-de-DE.js
+intl402/NumberFormat/prototype/format/signDisplay-en-US.js
+intl402/NumberFormat/prototype/format/signDisplay-ja-JP.js
+intl402/NumberFormat/prototype/format/signDisplay-ko-KR.js
+intl402/NumberFormat/prototype/format/signDisplay-rounding.js
+intl402/NumberFormat/prototype/format/signDisplay-zh-TW.js
+intl402/NumberFormat/prototype/format/unit-de-DE.js
+intl402/NumberFormat/prototype/format/unit-en-US.js
+intl402/NumberFormat/prototype/format/unit-ja-JP.js
+intl402/NumberFormat/prototype/format/unit-ko-KR.js
+intl402/NumberFormat/prototype/format/unit-zh-TW.js
+intl402/NumberFormat/prototype/format/units.js
+intl402/NumberFormat/prototype/format/value-arg-coerced-to-number.js
+intl402/NumberFormat/prototype/format/value-tonumber.js
+intl402/NumberFormat/prototype/formatToParts/default-parameter.js
+intl402/NumberFormat/prototype/formatToParts/engineering-scientific-de-DE.js
+intl402/NumberFormat/prototype/formatToParts/engineering-scientific-en-US.js
+intl402/NumberFormat/prototype/formatToParts/engineering-scientific-ja-JP.js
+intl402/NumberFormat/prototype/formatToParts/engineering-scientific-ko-KR.js
+intl402/NumberFormat/prototype/formatToParts/engineering-scientific-zh-TW.js
+intl402/NumberFormat/prototype/formatToParts/main.js
+intl402/NumberFormat/prototype/formatToParts/notation-compact-de-DE.js
+intl402/NumberFormat/prototype/formatToParts/notation-compact-en-US.js
+intl402/NumberFormat/prototype/formatToParts/notation-compact-ja-JP.js
+intl402/NumberFormat/prototype/formatToParts/notation-compact-ko-KR.js
+intl402/NumberFormat/prototype/formatToParts/notation-compact-zh-TW.js
+intl402/NumberFormat/prototype/formatToParts/percent-en-US.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-currency-de-DE.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-currency-en-US.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-currency-ja-JP.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-currency-ko-KR.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-currency-zh-TW.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-de-DE.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-en-US.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-ja-JP.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-ko-KR.js
+intl402/NumberFormat/prototype/formatToParts/signDisplay-zh-TW.js
+intl402/NumberFormat/prototype/formatToParts/unit-de-DE.js
+intl402/NumberFormat/prototype/formatToParts/unit-en-US.js
+intl402/NumberFormat/prototype/formatToParts/unit-ja-JP.js
+intl402/NumberFormat/prototype/formatToParts/unit-ko-KR.js
+intl402/NumberFormat/prototype/formatToParts/unit-zh-TW.js
+intl402/NumberFormat/prototype/formatToParts/unit.js
+intl402/NumberFormat/prototype/formatToParts/value-tonumber.js
+intl402/NumberFormat/subclassing.js
+intl402/NumberFormat/supportedLocalesOf/basic.js
+intl402/NumberFormat/this-value-ignored.js
+intl402/PluralRules/builtin.js
+intl402/PluralRules/can-be-subclassed.js
+intl402/PluralRules/constructor-options-throwing-getters.js
+intl402/PluralRules/default-options-object-prototype.js
+intl402/PluralRules/internals.js
+intl402/PluralRules/length.js
+intl402/PluralRules/name.js
+intl402/PluralRules/prop-desc.js
+intl402/PluralRules/proto-from-ctor-realm.js
+intl402/PluralRules/prototype/bind.js
+intl402/PluralRules/prototype/builtins.js
+intl402/PluralRules/prototype/constructor/main.js
+intl402/PluralRules/prototype/constructor/prop-desc.js
+intl402/PluralRules/prototype/properties.js
+intl402/PluralRules/prototype/resolvedOptions/builtins.js
+intl402/PluralRules/prototype/resolvedOptions/length.js
+intl402/PluralRules/prototype/resolvedOptions/name.js
+intl402/PluralRules/prototype/resolvedOptions/order.js
+intl402/PluralRules/prototype/resolvedOptions/pluralCategories.js
+intl402/PluralRules/prototype/resolvedOptions/prop-desc.js
+intl402/PluralRules/prototype/resolvedOptions/properties.js
+intl402/PluralRules/prototype/select/length.js
+intl402/PluralRules/prototype/select/name.js
+intl402/PluralRules/prototype/select/non-finite.js
+intl402/PluralRules/prototype/select/prop-desc.js
+intl402/PluralRules/prototype/select/tainting.js
+intl402/PluralRules/prototype/toStringTag/toString-changed-tag.js
+intl402/PluralRules/prototype/toStringTag/toString-removed-tag.js
+intl402/PluralRules/prototype/toStringTag/toString.js
+intl402/PluralRules/prototype/toStringTag/toStringTag.js
+intl402/PluralRules/supportedLocalesOf/arguments.js
+intl402/PluralRules/supportedLocalesOf/length.js
+intl402/PluralRules/supportedLocalesOf/main.js
+intl402/PluralRules/supportedLocalesOf/name.js
+intl402/PluralRules/supportedLocalesOf/prop-desc.js
+intl402/PluralRules/supportedLocalesOf/supportedLocalesOf.js
+intl402/PluralRules/undefined-newtarget-throws.js
+intl402/RelativeTimeFormat/constructor/constructor/locales-valid.js
+intl402/RelativeTimeFormat/constructor/constructor/options-numberingSystem-valid.js
+intl402/RelativeTimeFormat/constructor/constructor/options-numeric-valid.js
+intl402/RelativeTimeFormat/constructor/constructor/options-order.js
+intl402/RelativeTimeFormat/constructor/constructor/options-proto.js
+intl402/RelativeTimeFormat/constructor/constructor/options-style-valid.js
+intl402/RelativeTimeFormat/constructor/constructor/options-toobject-prototype.js
+intl402/RelativeTimeFormat/constructor/constructor/options-toobject.js
+intl402/RelativeTimeFormat/constructor/constructor/options-undefined.js
+intl402/RelativeTimeFormat/constructor/constructor/proto-from-ctor-realm.js
+intl402/RelativeTimeFormat/constructor/constructor/subclassing.js
+intl402/RelativeTimeFormat/constructor/supportedLocalesOf/basic.js
+intl402/RelativeTimeFormat/constructor/supportedLocalesOf/result-type.js
+intl402/RelativeTimeFormat/instance/extensibility.js
+intl402/RelativeTimeFormat/instance/prototype.js
+intl402/RelativeTimeFormat/prototype/format/en-us-numeric-always.js
+intl402/RelativeTimeFormat/prototype/format/en-us-numeric-auto.js
+intl402/RelativeTimeFormat/prototype/format/en-us-style-short.js
+intl402/RelativeTimeFormat/prototype/format/pl-pl-style-long.js
+intl402/RelativeTimeFormat/prototype/format/pl-pl-style-narrow.js
+intl402/RelativeTimeFormat/prototype/format/pl-pl-style-short.js
+intl402/RelativeTimeFormat/prototype/format/unit-invalid.js
+intl402/RelativeTimeFormat/prototype/format/unit-plural.js
+intl402/RelativeTimeFormat/prototype/format/value-non-finite.js
+intl402/RelativeTimeFormat/prototype/format/value-symbol.js
+intl402/RelativeTimeFormat/prototype/format/value-tonumber.js
+intl402/RelativeTimeFormat/prototype/formatToParts/en-us-numeric-always.js
+intl402/RelativeTimeFormat/prototype/formatToParts/en-us-numeric-auto.js
+intl402/RelativeTimeFormat/prototype/formatToParts/en-us-style-short.js
+intl402/RelativeTimeFormat/prototype/formatToParts/pl-pl-style-long.js
+intl402/RelativeTimeFormat/prototype/formatToParts/pl-pl-style-narrow.js
+intl402/RelativeTimeFormat/prototype/formatToParts/pl-pl-style-short.js
+intl402/RelativeTimeFormat/prototype/formatToParts/result-type.js
+intl402/RelativeTimeFormat/prototype/formatToParts/unit-invalid.js
+intl402/RelativeTimeFormat/prototype/formatToParts/unit-plural.js
+intl402/RelativeTimeFormat/prototype/formatToParts/value-non-finite.js
+intl402/RelativeTimeFormat/prototype/formatToParts/value-symbol.js
+intl402/RelativeTimeFormat/prototype/formatToParts/value-tonumber.js
+intl402/RelativeTimeFormat/prototype/resolvedOptions/caching.js
+intl402/RelativeTimeFormat/prototype/resolvedOptions/order.js
+intl402/RelativeTimeFormat/prototype/resolvedOptions/type.js
+intl402/RelativeTimeFormat/prototype/toStringTag/toString.js
+intl402/Segmenter/constructor/constructor/locales-invalid.js
+intl402/Segmenter/constructor/constructor/locales-valid.js
+intl402/Segmenter/constructor/constructor/newtarget-undefined.js
+intl402/Segmenter/constructor/constructor/options-granularity-invalid.js
+intl402/Segmenter/constructor/constructor/options-granularity-valid.js
+intl402/Segmenter/constructor/constructor/options-invalid.js
+intl402/Segmenter/constructor/constructor/options-localeMatcher-invalid.js
+intl402/Segmenter/constructor/constructor/options-order.js
+intl402/Segmenter/constructor/constructor/options-throwing-getters.js
+intl402/Segmenter/constructor/constructor/options-toobject-prototype.js
+intl402/Segmenter/constructor/constructor/options-toobject.js
+intl402/Segmenter/constructor/constructor/options-undefined.js
+intl402/Segmenter/constructor/constructor/options-valid-combinations.js
+intl402/Segmenter/constructor/constructor/proto-from-ctor-realm.js
+intl402/Segmenter/constructor/constructor/subclassing.js
+intl402/Segmenter/constructor/length.js
+intl402/Segmenter/constructor/name.js
+intl402/Segmenter/constructor/prop-desc.js
+intl402/Segmenter/constructor/prototype.js
+intl402/Segmenter/constructor/supportedLocalesOf/basic.js
+intl402/Segmenter/constructor/supportedLocalesOf/branding.js
+intl402/Segmenter/constructor/supportedLocalesOf/length.js
+intl402/Segmenter/constructor/supportedLocalesOf/locales-empty.js
+intl402/Segmenter/constructor/supportedLocalesOf/locales-invalid.js
+intl402/Segmenter/constructor/supportedLocalesOf/locales-specific.js
+intl402/Segmenter/constructor/supportedLocalesOf/name.js
+intl402/Segmenter/constructor/supportedLocalesOf/options-localeMatcher-invalid.js
+intl402/Segmenter/constructor/supportedLocalesOf/options-null.js
+intl402/Segmenter/constructor/supportedLocalesOf/options-toobject.js
+intl402/Segmenter/constructor/supportedLocalesOf/options-undefined.js
+intl402/Segmenter/constructor/supportedLocalesOf/prop-desc.js
+intl402/Segmenter/constructor/supportedLocalesOf/result-type.js
+intl402/Segmenter/instance/extensibility.js
+intl402/Segmenter/instance/prototype.js
+intl402/Segmenter/prototype/constructor/prop-desc.js
+intl402/Segmenter/prototype/prop-desc.js
+intl402/Segmenter/prototype/resolvedOptions/branding.js
+intl402/Segmenter/prototype/resolvedOptions/caching.js
+intl402/Segmenter/prototype/resolvedOptions/length.js
+intl402/Segmenter/prototype/resolvedOptions/name.js
+intl402/Segmenter/prototype/resolvedOptions/order.js
+intl402/Segmenter/prototype/resolvedOptions/prop-desc.js
+intl402/Segmenter/prototype/resolvedOptions/type-without-lbs.js
+intl402/Segmenter/prototype/segment/branding.js
+intl402/Segmenter/prototype/segment/length.js
+intl402/Segmenter/prototype/segment/name.js
+intl402/Segmenter/prototype/segment/prop-desc.js
+intl402/Segmenter/prototype/segment/segment-grapheme-iterable.js
+intl402/Segmenter/prototype/segment/segment-grapheme.js
+intl402/Segmenter/prototype/segment/segment-sentence-iterable.js
+intl402/Segmenter/prototype/segment/segment-sentence.js
+intl402/Segmenter/prototype/segment/segment-tostring.js
+intl402/Segmenter/prototype/segment/segment-word-iterable.js
+intl402/Segmenter/prototype/segment/segment-word.js
+intl402/Segmenter/prototype/toStringTag/toString.js
+intl402/Segmenter/prototype/toStringTag/toStringTag.js
+intl402/String/prototype/localeCompare/default-options-object-prototype.js
+intl402/String/prototype/localeCompare/returns-same-results-as-Collator.js
+intl402/String/prototype/localeCompare/throws-same-exceptions-as-Collator.js
+intl402/String/prototype/toLocaleLowerCase/special_casing_Azeri.js
+intl402/String/prototype/toLocaleLowerCase/special_casing_Lithuanian.js
+intl402/String/prototype/toLocaleLowerCase/special_casing_Turkish.js
+intl402/String/prototype/toLocaleUpperCase/special_casing_Azeri.js
+intl402/String/prototype/toLocaleUpperCase/special_casing_Lithuanian.js
+intl402/String/prototype/toLocaleUpperCase/special_casing_Turkish.js
+intl402/TypedArray/prototype/toLocaleString/calls-toLocaleString-number-elements.js
+intl402/constructors-string-and-single-element-array.js
+intl402/constructors-taint-Object-prototype-2.js
+intl402/constructors-taint-Object-prototype.js
+intl402/default-locale-is-canonicalized.js
+intl402/default-locale-is-supported.js
+intl402/fallback-locales-are-supported.js
+intl402/language-tags-canonicalized.js
+intl402/language-tags-invalid.js
+intl402/language-tags-valid.js
+intl402/language-tags-with-underscore.js
+intl402/supportedLocalesOf-consistent-with-resolvedOptions.js
+intl402/supportedLocalesOf-default-locale-and-zxx-locale.js
+intl402/supportedLocalesOf-duplicate-elements-removed.js
+intl402/supportedLocalesOf-empty-and-undefined.js
+intl402/supportedLocalesOf-locales-arg-coered-to-object.js
+intl402/supportedLocalesOf-locales-arg-empty-array.js
+intl402/supportedLocalesOf-returned-array-elements-are-not-frozen.js
+intl402/supportedLocalesOf-taint-Array-2.js
+intl402/supportedLocalesOf-taint-Array.js
+intl402/supportedLocalesOf-test-option-localeMatcher.js
+intl402/supportedLocalesOf-unicode-extensions-ignored.js
+language/arguments-object/10.5-1-s.js
+language/arguments-object/10.5-7-b-1-s.js
+language/comments/S7.4_A5.js
+language/comments/S7.4_A6.js
+language/comments/hashbang/eval-indirect.js
+language/comments/hashbang/eval.js
+language/comments/hashbang/function-constructor.js
+language/comments/hashbang/no-line-separator.js
+language/comments/mongolian-vowel-separator-single-eval.js
+language/computed-property-names/class/static/method-number.js
+language/computed-property-names/class/static/method-string.js
+language/computed-property-names/class/static/method-symbol.js
+language/eval-code/direct/block-decl-eval-source-is-strict-onlystrict.js
+language/eval-code/direct/block-decl-onlystrict.js
+language/eval-code/direct/cptn-nrml-empty-block.js
+language/eval-code/direct/cptn-nrml-empty-do-while.js
+language/eval-code/direct/cptn-nrml-empty-empty.js
+language/eval-code/direct/cptn-nrml-empty-for.js
+language/eval-code/direct/cptn-nrml-empty-if.js
+language/eval-code/direct/cptn-nrml-empty-switch.js
+language/eval-code/direct/cptn-nrml-empty-var.js
+language/eval-code/direct/cptn-nrml-empty-while.js
+language/eval-code/direct/cptn-nrml-expr-obj.js
+language/eval-code/direct/cptn-nrml-expr-prim.js
+language/eval-code/direct/cptn-thrw-prim.js
+language/eval-code/direct/export.js
+language/eval-code/direct/global-env-rec-catch.js
+language/eval-code/direct/global-env-rec-eval.js
+language/eval-code/direct/global-env-rec-fun.js
+language/eval-code/direct/global-env-rec.js
+language/eval-code/direct/import.js
+language/eval-code/direct/lex-env-distinct-cls.js
+language/eval-code/direct/lex-env-distinct-const.js
+language/eval-code/direct/lex-env-distinct-let.js
+language/eval-code/direct/lex-env-heritage.js
+language/eval-code/direct/lex-env-no-init-cls.js
+language/eval-code/direct/lex-env-no-init-const.js
+language/eval-code/direct/lex-env-no-init-let.js
+language/eval-code/direct/new.target-arrow.js
+language/eval-code/direct/new.target-fn.js
+language/eval-code/direct/new.target.js
+language/eval-code/direct/non-string-object.js
+language/eval-code/direct/non-string-primitive.js
+language/eval-code/direct/parse-failure-1.js
+language/eval-code/direct/parse-failure-2.js
+language/eval-code/direct/parse-failure-3.js
+language/eval-code/direct/parse-failure-4.js
+language/eval-code/direct/parse-failure-5.js
+language/eval-code/direct/strict-caller-function-context.js
+language/eval-code/direct/strict-caller-global.js
+language/eval-code/direct/strictness-override.js
+language/eval-code/direct/super-call-arrow.js
+language/eval-code/direct/super-call-fn.js
+language/eval-code/direct/super-call-method.js
+language/eval-code/direct/super-call.js
+language/eval-code/direct/super-prop-arrow.js
+language/eval-code/direct/super-prop-dot-no-home.js
+language/eval-code/direct/super-prop-expr-no-home.js
+language/eval-code/direct/super-prop-method.js
+language/eval-code/direct/super-prop.js
+language/eval-code/direct/switch-case-decl-eval-source-is-strict-onlystrict.js
+language/eval-code/direct/switch-case-decl-onlystrict.js
+language/eval-code/direct/switch-dflt-decl-eval-source-is-strict-onlystrict.js
+language/eval-code/direct/switch-dflt-decl-onlystrict.js
+language/eval-code/direct/this-value-func-strict-caller.js
+language/eval-code/direct/this-value-global.js
+language/eval-code/direct/var-env-func-strict-caller-2.js
+language/eval-code/direct/var-env-func-strict-caller.js
+language/eval-code/direct/var-env-func-strict-source.js
+language/eval-code/direct/var-env-gloabl-lex-strict-caller.js
+language/eval-code/direct/var-env-global-lex-strict-source.js
+language/eval-code/direct/var-env-lower-lex-strict-caller.js
+language/eval-code/direct/var-env-lower-lex-strict-source.js
+language/eval-code/direct/var-env-var-strict-caller-2.js
+language/eval-code/direct/var-env-var-strict-caller-3.js
+language/eval-code/direct/var-env-var-strict-caller.js
+language/eval-code/direct/var-env-var-strict-source.js
+language/eval-code/indirect/always-non-strict.js
+language/eval-code/indirect/block-decl-strict.js
+language/eval-code/indirect/cptn-nrml-empty-block.js
+language/eval-code/indirect/cptn-nrml-empty-do-while.js
+language/eval-code/indirect/cptn-nrml-empty-empty.js
+language/eval-code/indirect/cptn-nrml-empty-for.js
+language/eval-code/indirect/cptn-nrml-empty-if.js
+language/eval-code/indirect/cptn-nrml-empty-switch.js
+language/eval-code/indirect/cptn-nrml-empty-var.js
+language/eval-code/indirect/cptn-nrml-empty-while.js
+language/eval-code/indirect/cptn-nrml-expr-obj.js
+language/eval-code/indirect/cptn-nrml-expr-prim.js
+language/eval-code/indirect/export.js
+language/eval-code/indirect/global-env-rec-catch.js
+language/eval-code/indirect/global-env-rec-eval.js
+language/eval-code/indirect/global-env-rec-fun.js
+language/eval-code/indirect/global-env-rec.js
+language/eval-code/indirect/import.js
+language/eval-code/indirect/lex-env-distinct-cls.js
+language/eval-code/indirect/lex-env-distinct-const.js
+language/eval-code/indirect/lex-env-distinct-let.js
+language/eval-code/indirect/lex-env-heritage.js
+language/eval-code/indirect/lex-env-no-init-cls.js
+language/eval-code/indirect/lex-env-no-init-const.js
+language/eval-code/indirect/lex-env-no-init-let.js
+language/eval-code/indirect/new.target.js
+language/eval-code/indirect/non-string-object.js
+language/eval-code/indirect/non-string-primitive.js
+language/eval-code/indirect/parse-failure-1.js
+language/eval-code/indirect/parse-failure-2.js
+language/eval-code/indirect/parse-failure-3.js
+language/eval-code/indirect/parse-failure-4.js
+language/eval-code/indirect/parse-failure-5.js
+language/eval-code/indirect/realm.js
+language/eval-code/indirect/super-call.js
+language/eval-code/indirect/super-prop.js
+language/eval-code/indirect/switch-case-decl-strict.js
+language/eval-code/indirect/switch-dflt-decl-strict.js
+language/eval-code/indirect/this-value-func.js
+language/eval-code/indirect/this-value-global.js
+language/eval-code/indirect/var-env-func-init-global-new.js
+language/eval-code/indirect/var-env-func-init-global-update-configurable.js
+language/eval-code/indirect/var-env-func-init-global-update-non-configurable.js
+language/eval-code/indirect/var-env-func-init-multi.js
+language/eval-code/indirect/var-env-func-non-strict.js
+language/eval-code/indirect/var-env-func-strict.js
+language/eval-code/indirect/var-env-global-lex-non-strict.js
+language/eval-code/indirect/var-env-global-lex-strict.js
+language/eval-code/indirect/var-env-lower-lex-non-strict.js
+language/eval-code/indirect/var-env-lower-lex-strict.js
+language/eval-code/indirect/var-env-var-init-global-exstng.js
+language/eval-code/indirect/var-env-var-init-global-new.js
+language/eval-code/indirect/var-env-var-non-strict.js
+language/eval-code/indirect/var-env-var-strict.js
+language/expressions/addition/S11.6.1_A1.js
+language/expressions/array/spread-err-mult-err-expr-throws.js
+language/expressions/array/spread-err-mult-err-iter-get-value.js
+language/expressions/array/spread-err-mult-err-itr-get-call.js
+language/expressions/array/spread-err-mult-err-itr-get-get.js
+language/expressions/array/spread-err-mult-err-itr-step.js
+language/expressions/array/spread-err-mult-err-itr-value.js
+language/expressions/array/spread-err-sngl-err-expr-throws.js
+language/expressions/array/spread-err-sngl-err-itr-get-call.js
+language/expressions/array/spread-err-sngl-err-itr-get-get.js
+language/expressions/array/spread-err-sngl-err-itr-get-value.js
+language/expressions/array/spread-err-sngl-err-itr-step.js
+language/expressions/array/spread-err-sngl-err-itr-value.js
+language/expressions/array/spread-mult-iter.js
+language/expressions/array/spread-obj-getter-descriptor.js
+language/expressions/array/spread-obj-manipulate-outter-obj-in-getter.js
+language/expressions/array/spread-obj-mult-spread-getter.js
+language/expressions/array/spread-obj-override-immutable.js
+language/expressions/array/spread-obj-spread-order.js
+language/expressions/array/spread-sngl-iter.js
+language/expressions/arrow-function/arrow/capturing-closure-variables-1.js
+language/expressions/arrow-function/dflt-params-ref-later.js
+language/expressions/arrow-function/dflt-params-ref-self.js
+language/expressions/assignment/S11.13.1_A5_T5.js
+language/expressions/assignment/S11.13.1_A7_T1.js
+language/expressions/assignment/S11.13.1_A7_T2.js
+language/expressions/assignment/S11.13.1_A7_T3.js
+language/expressions/assignment/destructuring/iterator-destructuring-property-reference-target-evaluation-order.js
+language/expressions/assignment/destructuring/keyed-destructuring-property-reference-target-evaluation-order.js
+language/expressions/assignment/dstr/array-elem-iter-rtrn-close-err.js
+language/expressions/assignment/dstr/array-elem-iter-rtrn-close-null.js
+language/expressions/assignment/dstr/array-elem-iter-rtrn-close.js
+language/expressions/assignment/dstr/array-elem-trlg-iter-list-rtrn-close-err.js
+language/expressions/assignment/dstr/array-elem-trlg-iter-list-rtrn-close-null.js
+language/expressions/assignment/dstr/array-elem-trlg-iter-list-rtrn-close.js
+language/expressions/assignment/dstr/array-elem-trlg-iter-rest-rtrn-close-err.js
+language/expressions/assignment/dstr/array-elem-trlg-iter-rest-rtrn-close-null.js
+language/expressions/assignment/dstr/array-elem-trlg-iter-rest-rtrn-close.js
+language/expressions/assignment/dstr/array-rest-iter-rtrn-close-err.js
+language/expressions/assignment/dstr/array-rest-iter-rtrn-close-null.js
+language/expressions/assignment/dstr/array-rest-iter-rtrn-close.js
+language/expressions/assignment/dstr/array-rest-put-const.js
+language/expressions/assignment/dstr/array-rest-put-let.js
+language/expressions/assignment/dstr/obj-rest-computed-property.js
+language/expressions/assignment/dstr/obj-rest-number.js
+language/expressions/assignment/dstr/obj-rest-order.js
+language/expressions/assignment/dstr/obj-rest-put-const.js
+language/expressions/assignment/dstr/obj-rest-str-val.js
+language/expressions/assignment/dstr/obj-rest-symbol-val.js
+language/expressions/assignment/fn-name-lhs-cover.js
+language/expressions/async-arrow-function/dflt-params-abrupt.js
+language/expressions/async-arrow-function/dflt-params-ref-later.js
+language/expressions/async-arrow-function/dflt-params-ref-self.js
+language/expressions/async-arrow-function/dflt-params-trailing-comma.js
+language/expressions/async-arrow-function/name.js
+language/expressions/async-arrow-function/params-trailing-comma-multiple.js
+language/expressions/async-arrow-function/params-trailing-comma-single.js
+language/expressions/async-function/name.js
+language/expressions/async-function/named-dflt-params-abrupt.js
+language/expressions/async-function/named-dflt-params-ref-later.js
+language/expressions/async-function/named-dflt-params-ref-self.js
+language/expressions/async-function/named-dflt-params-trailing-comma.js
+language/expressions/async-function/named-params-trailing-comma-multiple.js
+language/expressions/async-function/named-params-trailing-comma-single.js
+language/expressions/async-function/nameless-dflt-params-abrupt.js
+language/expressions/async-function/nameless-dflt-params-ref-later.js
+language/expressions/async-function/nameless-dflt-params-ref-self.js
+language/expressions/async-function/nameless-dflt-params-trailing-comma.js
+language/expressions/async-function/nameless-params-trailing-comma-multiple.js
+language/expressions/async-function/nameless-params-trailing-comma-single.js
+language/expressions/async-generator/dflt-params-ref-later.js
+language/expressions/async-generator/dflt-params-ref-self.js
+language/expressions/async-generator/eval-body-proto-realm.js
+language/expressions/async-generator/named-dflt-params-ref-later.js
+language/expressions/async-generator/named-dflt-params-ref-self.js
+language/expressions/async-generator/yield-star-getiter-async-throw-method-is-null.js
+language/expressions/bitwise-and/S11.10.1_A1.js
+language/expressions/bitwise-not/S11.4.8_A1.js
+language/expressions/bitwise-or/S11.10.3_A1.js
+language/expressions/bitwise-xor/S11.10.2_A1.js
+language/expressions/call/11.2.3-3_5.js
+language/expressions/call/S11.2.3_A1.js
+language/expressions/call/eval-first-arg.js
+language/expressions/call/eval-spread-empty-leading.js
+language/expressions/call/eval-spread-empty-trailing.js
+language/expressions/call/eval-spread-empty.js
+language/expressions/call/eval-spread.js
+language/expressions/call/eval-strictness-inherit-strict.js
+language/expressions/call/spread-err-mult-err-expr-throws.js
+language/expressions/call/spread-err-mult-err-iter-get-value.js
+language/expressions/call/spread-err-mult-err-itr-get-call.js
+language/expressions/call/spread-err-mult-err-itr-get-get.js
+language/expressions/call/spread-err-mult-err-itr-step.js
+language/expressions/call/spread-err-mult-err-itr-value.js
+language/expressions/call/spread-err-sngl-err-expr-throws.js
+language/expressions/call/spread-err-sngl-err-itr-get-call.js
+language/expressions/call/spread-err-sngl-err-itr-get-get.js
+language/expressions/call/spread-err-sngl-err-itr-get-value.js
+language/expressions/call/spread-err-sngl-err-itr-step.js
+language/expressions/call/spread-err-sngl-err-itr-value.js
+language/expressions/call/spread-mult-iter.js
+language/expressions/call/spread-obj-getter-descriptor.js
+language/expressions/call/spread-obj-manipulate-outter-obj-in-getter.js
+language/expressions/call/spread-obj-mult-spread-getter.js
+language/expressions/call/spread-obj-override-immutable.js
+language/expressions/call/spread-obj-spread-order.js
+language/expressions/call/spread-sngl-iter.js
+language/expressions/call/tco-call-args.js
+language/expressions/call/tco-call-args.js
+language/expressions/call/tco-cross-realm-class-construct.js
+language/expressions/call/tco-cross-realm-class-derived-construct.js
+language/expressions/call/tco-cross-realm-fun-call.js
+language/expressions/call/tco-cross-realm-fun-construct.js
+language/expressions/call/tco-member-args.js
+language/expressions/class/accessor-name-inst/computed-err-to-prop-key.js
+language/expressions/class/accessor-name-inst/computed.js
+language/expressions/class/accessor-name-static/computed-err-to-prop-key.js
+language/expressions/class/accessor-name-static/computed.js
+language/expressions/class/async-gen-method-static/dflt-params-ref-later.js
+language/expressions/class/async-gen-method-static/dflt-params-ref-self.js
+language/expressions/class/async-gen-method/dflt-params-ref-later.js
+language/expressions/class/async-gen-method/dflt-params-ref-self.js
+language/expressions/class/async-method-static/dflt-params-abrupt.js
+language/expressions/class/async-method-static/dflt-params-ref-later.js
+language/expressions/class/async-method-static/dflt-params-ref-self.js
+language/expressions/class/async-method/dflt-params-abrupt.js
+language/expressions/class/async-method/dflt-params-ref-later.js
+language/expressions/class/async-method/dflt-params-ref-self.js
+language/expressions/class/constructor-this-tdz-during-initializers.js
+language/expressions/class/elements/after-same-line-gen-computed-symbol-names.js
+language/expressions/class/elements/after-same-line-method-computed-symbol-names.js
+language/expressions/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
+language/expressions/class/elements/after-same-line-static-async-method-computed-symbol-names.js
+language/expressions/class/elements/after-same-line-static-gen-computed-symbol-names.js
+language/expressions/class/elements/after-same-line-static-method-computed-symbol-names.js
+language/expressions/class/elements/class-name-static-initializer-anonymous.js
+language/expressions/class/elements/class-name-static-initializer-decl.js
+language/expressions/class/elements/class-name-static-initializer-expr.js
+language/expressions/class/elements/computed-name-toprimitive-symbol.js
+language/expressions/class/elements/computed-name-toprimitive.js
+language/expressions/class/elements/derived-cls-direct-eval-contains-superproperty-1.js
+language/expressions/class/elements/derived-cls-direct-eval-contains-superproperty-2.js
+language/expressions/class/elements/derived-cls-direct-eval-err-contains-supercall-1.js
+language/expressions/class/elements/derived-cls-direct-eval-err-contains-supercall-2.js
+language/expressions/class/elements/derived-cls-direct-eval-err-contains-supercall.js
+language/expressions/class/elements/derived-cls-indirect-eval-contains-superproperty-1.js
+language/expressions/class/elements/derived-cls-indirect-eval-contains-superproperty-2.js
+language/expressions/class/elements/derived-cls-indirect-eval-err-contains-supercall-1.js
+language/expressions/class/elements/derived-cls-indirect-eval-err-contains-supercall-2.js
+language/expressions/class/elements/derived-cls-indirect-eval-err-contains-supercall.js
+language/expressions/class/elements/direct-eval-err-contains-arguments.js
+language/expressions/class/elements/direct-eval-err-contains-newtarget.js
+language/expressions/class/elements/evaluation-error/computed-name-referenceerror.js
+language/expressions/class/elements/evaluation-error/computed-name-toprimitive-err.js
+language/expressions/class/elements/evaluation-error/computed-name-toprimitive-returns-noncallable.js
+language/expressions/class/elements/evaluation-error/computed-name-toprimitive-returns-nonobject.js
+language/expressions/class/elements/evaluation-error/computed-name-tostring-err.js
+language/expressions/class/elements/evaluation-error/computed-name-valueof-err.js
+language/expressions/class/elements/fields-computed-name-static-propname-prototype.js
+language/expressions/class/elements/fields-run-once-on-double-super.js
+language/expressions/class/elements/indirect-eval-err-contains-arguments.js
+language/expressions/class/elements/indirect-eval-err-contains-newtarget.js
+language/expressions/class/elements/init-value-defined-after-class.js
+language/expressions/class/elements/multiple-definitions-computed-symbol-names.js
+language/expressions/class/elements/multiple-stacked-definitions-computed-symbol-names.js
+language/expressions/class/elements/new-no-sc-line-method-computed-symbol-names.js
+language/expressions/class/elements/new-sc-line-gen-computed-symbol-names.js
+language/expressions/class/elements/new-sc-line-method-computed-symbol-names.js
+language/expressions/class/elements/redeclaration-symbol.js
+language/expressions/class/elements/regular-definitions-computed-symbol-names.js
+language/expressions/class/elements/same-line-async-gen-computed-symbol-names.js
+language/expressions/class/elements/same-line-async-method-computed-symbol-names.js
+language/expressions/class/elements/same-line-gen-computed-symbol-names.js
+language/expressions/class/elements/same-line-method-computed-symbol-names.js
+language/expressions/class/elements/static-field-init-this-inside-arrow-function.js
+language/expressions/class/elements/static-field-init-with-this.js
+language/expressions/class/elements/static-field-redeclaration.js
+language/expressions/class/elements/wrapped-in-sc-computed-symbol-names.js
+language/expressions/class/gen-method-static/dflt-params-ref-later.js
+language/expressions/class/gen-method-static/dflt-params-ref-self.js
+language/expressions/class/gen-method/dflt-params-ref-later.js
+language/expressions/class/gen-method/dflt-params-ref-self.js
+language/expressions/class/method-static/dflt-params-ref-later.js
+language/expressions/class/method-static/dflt-params-ref-self.js
+language/expressions/class/method/dflt-params-ref-later.js
+language/expressions/class/method/dflt-params-ref-self.js
+language/expressions/class/name.js
+language/expressions/class/private-getter-brand-check-multiple-evaluations-of-class-function-ctor.js
+language/expressions/class/private-getter-brand-check-multiple-evaluations-of-class-realm-function-ctor.js
+language/expressions/class/private-method-brand-check-multiple-evaluations-of-class-function-ctor.js
+language/expressions/class/private-method-brand-check-multiple-evaluations-of-class-realm-function-ctor.js
+language/expressions/class/private-setter-brand-check-multiple-evaluations-of-class-function-ctor.js
+language/expressions/class/private-setter-brand-check-multiple-evaluations-of-class-realm-function-ctor.js
+language/expressions/class/private-static-field-multiple-evaluations-of-class-function-ctor.js
+language/expressions/class/private-static-getter-multiple-evaluations-of-class-function-ctor.js
+language/expressions/class/private-static-method-brand-check-multiple-evaluations-of-class-function-ctor.js
+language/expressions/class/private-static-setter-multiple-evaluations-of-class-function-ctor.js
+language/expressions/comma/S11.14_A1.js
+language/expressions/comma/tco-final.js
+language/expressions/compound-assignment/11.13.2-1-s.js
+language/expressions/compound-assignment/11.13.2-10-s.js
+language/expressions/compound-assignment/11.13.2-11-s.js
+language/expressions/compound-assignment/11.13.2-2-s.js
+language/expressions/compound-assignment/11.13.2-4-s.js
+language/expressions/compound-assignment/11.13.2-5-s.js
+language/expressions/compound-assignment/11.13.2-6-s.js
+language/expressions/compound-assignment/11.13.2-8-s.js
+language/expressions/compound-assignment/11.13.2-9-s.js
+language/expressions/compound-assignment/S11.13.2_A5.10_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.11_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.1_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.2_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.3_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.4_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.5_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.6_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.7_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.8_T5.js
+language/expressions/compound-assignment/S11.13.2_A5.9_T5.js
+language/expressions/compound-assignment/S11.13.2_A7.10_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.10_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.10_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.11_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.11_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.11_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.1_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.1_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.1_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.2_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.2_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.2_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.3_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.3_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.3_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.4_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.4_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.4_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.5_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.5_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.5_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.6_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.6_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.6_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.7_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.7_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.7_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.8_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.8_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.8_T4.js
+language/expressions/compound-assignment/S11.13.2_A7.9_T1.js
+language/expressions/compound-assignment/S11.13.2_A7.9_T2.js
+language/expressions/compound-assignment/S11.13.2_A7.9_T4.js
+language/expressions/concatenation/S9.8_A1_T2.js
+language/expressions/conditional/S11.12_A1.js
+language/expressions/conditional/tco-cond.js
+language/expressions/conditional/tco-pos.js
+language/expressions/delete/super-property.js
+language/expressions/division/S11.5.2_A1.js
+language/expressions/division/no-magic-asi-from-block-eval.js
+language/expressions/does-not-equals/S11.9.2_A1.js
+language/expressions/does-not-equals/S11.9.2_A5.3.js
+language/expressions/does-not-equals/S11.9.2_A6.1.js
+language/expressions/dynamic-import/usage-from-eval.js
+language/expressions/equals/S11.9.1_A1.js
+language/expressions/equals/S11.9.1_A5.3.js
+language/expressions/equals/S11.9.1_A6.1.js
+language/expressions/function/dflt-params-ref-later.js
+language/expressions/function/dflt-params-ref-self.js
+language/expressions/generators/dflt-params-ref-later.js
+language/expressions/generators/dflt-params-ref-self.js
+language/expressions/generators/eval-body-proto-realm.js
+language/expressions/greater-than-or-equal/S11.8.4_A1.js
+language/expressions/greater-than/S11.8.2_A1.js
+language/expressions/grouping/S11.1.6_A1.js
+language/expressions/import.meta/not-accessible-from-direct-eval.js
+language/expressions/import.meta/syntax/goal-async-function-params-or-body.js
+language/expressions/import.meta/syntax/goal-async-generator-params-or-body.js
+language/expressions/import.meta/syntax/goal-function-params-or-body.js
+language/expressions/import.meta/syntax/goal-generator-params-or-body.js
+language/expressions/in/S11.8.7_A1.js
+language/expressions/instanceof/S11.8.6_A1.js
+language/expressions/instanceof/S15.3.5.3_A1_T1.js
+language/expressions/instanceof/S15.3.5.3_A1_T2.js
+language/expressions/instanceof/S15.3.5.3_A1_T3.js
+language/expressions/instanceof/S15.3.5.3_A1_T4.js
+language/expressions/instanceof/S15.3.5.3_A1_T5.js
+language/expressions/instanceof/S15.3.5.3_A1_T6.js
+language/expressions/instanceof/S15.3.5.3_A1_T7.js
+language/expressions/instanceof/S15.3.5.3_A1_T8.js
+language/expressions/instanceof/S15.3.5.3_A2_T5.js
+language/expressions/instanceof/S15.3.5.3_A3_T1.js
+language/expressions/instanceof/S15.3.5.3_A3_T2.js
+language/expressions/left-shift/S11.7.1_A1.js
+language/expressions/less-than-or-equal/S11.8.3_A1.js
+language/expressions/less-than/S11.8.1_A1.js
+language/expressions/logical-and/S11.11.1_A1.js
+language/expressions/logical-and/tco-right.js
+language/expressions/logical-not/S11.4.9_A1.js
+language/expressions/logical-not/S9.2_A1_T2.js
+language/expressions/logical-or/S11.11.2_A1.js
+language/expressions/logical-or/tco-right.js
+language/expressions/modulus/S11.5.3_A1.js
+language/expressions/multiplication/S11.5.1_A1.js
+language/expressions/new/S11.2.2_A1.1.js
+language/expressions/new/S11.2.2_A1.2.js
+language/expressions/new/spread-err-mult-err-expr-throws.js
+language/expressions/new/spread-err-mult-err-iter-get-value.js
+language/expressions/new/spread-err-mult-err-itr-get-call.js
+language/expressions/new/spread-err-mult-err-itr-get-get.js
+language/expressions/new/spread-err-mult-err-itr-step.js
+language/expressions/new/spread-err-mult-err-itr-value.js
+language/expressions/new/spread-err-sngl-err-expr-throws.js
+language/expressions/new/spread-err-sngl-err-itr-get-call.js
+language/expressions/new/spread-err-sngl-err-itr-get-get.js
+language/expressions/new/spread-err-sngl-err-itr-get-value.js
+language/expressions/new/spread-err-sngl-err-itr-step.js
+language/expressions/new/spread-err-sngl-err-itr-value.js
+language/expressions/new/spread-mult-iter.js
+language/expressions/new/spread-obj-getter-descriptor.js
+language/expressions/new/spread-obj-manipulate-outter-obj-in-getter.js
+language/expressions/new/spread-obj-mult-spread-getter.js
+language/expressions/new/spread-obj-override-immutable.js
+language/expressions/new/spread-obj-spread-order.js
+language/expressions/new/spread-sngl-iter.js
+language/expressions/object/11.1.5-0-1.js
+language/expressions/object/11.1.5-0-2.js
+language/expressions/object/11.1.5_4-4-a-3.js
+language/expressions/object/11.1.5_4-4-b-1.js
+language/expressions/object/11.1.5_6-3-1.js
+language/expressions/object/11.1.5_6-3-2.js
+language/expressions/object/11.1.5_7-3-1.js
+language/expressions/object/11.1.5_7-3-2.js
+language/expressions/object/accessor-name-computed-err-to-prop-key.js
+language/expressions/object/accessor-name-computed.js
+language/expressions/object/accessor-name-literal-numeric-leading-decimal.js
+language/expressions/object/accessor-name-literal-numeric-non-canonical.js
+language/expressions/object/method-definition/async-gen-meth-dflt-params-ref-later.js
+language/expressions/object/method-definition/async-gen-meth-dflt-params-ref-self.js
+language/expressions/object/method-definition/async-meth-dflt-params-abrupt.js
+language/expressions/object/method-definition/async-meth-dflt-params-ref-later.js
+language/expressions/object/method-definition/async-meth-dflt-params-ref-self.js
+language/expressions/object/method-definition/gen-meth-dflt-params-ref-later.js
+language/expressions/object/method-definition/gen-meth-dflt-params-ref-self.js
+language/expressions/object/method-definition/meth-dflt-params-ref-later.js
+language/expressions/object/method-definition/meth-dflt-params-ref-self.js
+language/expressions/optional-chaining/call-expression.js
+language/expressions/optional-chaining/eval-optional-call.js
+language/expressions/optional-chaining/iteration-statement-for-await-of.js
+language/expressions/optional-chaining/iteration-statement-for-in.js
+language/expressions/optional-chaining/iteration-statement-for-of-type-error.js
+language/expressions/optional-chaining/iteration-statement-for.js
+language/expressions/optional-chaining/member-expression-async-identifier.js
+language/expressions/optional-chaining/member-expression-async-literal.js
+language/expressions/optional-chaining/member-expression-async-this.js
+language/expressions/optional-chaining/member-expression.js
+language/expressions/optional-chaining/new-target-optional-call.js
+language/expressions/optional-chaining/optional-call-preserves-this.js
+language/expressions/optional-chaining/optional-chain-async-optional-chain-square-brackets.js
+language/expressions/optional-chaining/optional-chain-async-square-brackets.js
+language/expressions/optional-chaining/optional-chain-prod-arguments.js
+language/expressions/optional-chaining/optional-chain-prod-expression.js
+language/expressions/optional-chaining/optional-chain-prod-identifiername.js
+language/expressions/optional-chaining/super-property-optional-call.js
+language/expressions/postfix-decrement/S11.3.2_A5_T5.js
+language/expressions/postfix-decrement/S11.3.2_A6_T1.js
+language/expressions/postfix-decrement/S11.3.2_A6_T2.js
+language/expressions/postfix-decrement/S11.3.2_A6_T3.js
+language/expressions/postfix-increment/S11.3.1_A5_T5.js
+language/expressions/postfix-increment/S11.3.1_A6_T1.js
+language/expressions/postfix-increment/S11.3.1_A6_T2.js
+language/expressions/postfix-increment/S11.3.1_A6_T3.js
+language/expressions/prefix-decrement/S11.4.5_A5_T5.js
+language/expressions/prefix-decrement/S11.4.5_A6_T1.js
+language/expressions/prefix-decrement/S11.4.5_A6_T2.js
+language/expressions/prefix-decrement/S11.4.5_A6_T3.js
+language/expressions/prefix-increment/S11.4.4_A5_T5.js
+language/expressions/prefix-increment/S11.4.4_A6_T1.js
+language/expressions/prefix-increment/S11.4.4_A6_T2.js
+language/expressions/prefix-increment/S11.4.4_A6_T3.js
+language/expressions/property-accessors/S11.2.1_A1.1.js
+language/expressions/property-accessors/S11.2.1_A1.2.js
+language/expressions/right-shift/S11.7.2_A1.js
+language/expressions/strict-does-not-equals/S11.9.5_A1.js
+language/expressions/strict-does-not-equals/S11.9.5_A6.1.js
+language/expressions/strict-equals/S11.9.4_A1.js
+language/expressions/strict-equals/S11.9.4_A6.1.js
+language/expressions/subtraction/S11.6.2_A1.js
+language/expressions/super/call-spread-err-mult-err-expr-throws.js
+language/expressions/super/call-spread-err-mult-err-iter-get-value.js
+language/expressions/super/call-spread-err-mult-err-itr-get-call.js
+language/expressions/super/call-spread-err-mult-err-itr-get-get.js
+language/expressions/super/call-spread-err-mult-err-itr-step.js
+language/expressions/super/call-spread-err-mult-err-itr-value.js
+language/expressions/super/call-spread-err-sngl-err-expr-throws.js
+language/expressions/super/call-spread-err-sngl-err-itr-get-call.js
+language/expressions/super/call-spread-err-sngl-err-itr-get-get.js
+language/expressions/super/call-spread-err-sngl-err-itr-get-value.js
+language/expressions/super/call-spread-err-sngl-err-itr-step.js
+language/expressions/super/call-spread-err-sngl-err-itr-value.js
+language/expressions/super/call-spread-mult-iter.js
+language/expressions/super/call-spread-obj-getter-descriptor.js
+language/expressions/super/call-spread-obj-manipulate-outter-obj-in-getter.js
+language/expressions/super/call-spread-obj-mult-spread-getter.js
+language/expressions/super/call-spread-obj-override-immutable.js
+language/expressions/super/call-spread-obj-spread-order.js
+language/expressions/super/call-spread-sngl-iter.js
+language/expressions/super/prop-dot-cls-val-from-eval.js
+language/expressions/super/prop-dot-obj-val-from-eval.js
+language/expressions/super/prop-expr-cls-val-from-eval.js
+language/expressions/super/prop-expr-obj-val-from-eval.js
+language/expressions/super/realm.js
+language/expressions/tagged-template/cache-different-functions-same-site.js
+language/expressions/tagged-template/cache-differing-expressions-eval.js
+language/expressions/tagged-template/cache-differing-expressions-new-function.js
+language/expressions/tagged-template/cache-eval-inner-function.js
+language/expressions/tagged-template/cache-identical-source-eval.js
+language/expressions/tagged-template/cache-identical-source-new-function.js
+language/expressions/tagged-template/cache-realm.js
+language/expressions/tagged-template/cache-same-site-top-level.js
+language/expressions/tagged-template/cache-same-site.js
+language/expressions/tagged-template/tco-call.js
+language/expressions/tagged-template/tco-call.js
+language/expressions/tagged-template/tco-member.js
+language/expressions/tagged-template/tco-member.js
+language/expressions/tagged-template/template-object-template-map.js
+language/expressions/tagged-template/template-object.js
+language/expressions/tco-pos.js
+language/expressions/template-literal/mongolian-vowel-separator-eval.js
+language/expressions/this/S11.1.1_A3.2.js
+language/expressions/this/S11.1.1_A4.1.js
+language/expressions/this/S11.1.1_A4.2.js
+language/expressions/typeof/syntax.js
+language/expressions/unary-minus/S11.4.7_A1.js
+language/expressions/unary-plus/S11.4.6_A1.js
+language/expressions/unary-plus/S9.3_A1_T2.js
+language/expressions/unsigned-right-shift/S11.7.3_A1.js
+language/expressions/void/S11.4.2_A1.js
+language/function-code/10.4.3-1-13-s.js
+language/function-code/10.4.3-1-13gs.js
+language/function-code/10.4.3-1-15-s.js
+language/function-code/10.4.3-1-15gs.js
+language/function-code/10.4.3-1-17-s.js
+language/function-code/10.4.3-1-17gs.js
+language/function-code/10.4.3-1-19-s.js
+language/function-code/10.4.3-1-19gs.js
+language/function-code/10.4.3-1-63-s.js
+language/function-code/10.4.3-1-63gs.js
+language/function-code/10.4.3-1-64-s.js
+language/function-code/10.4.3-1-64gs.js
+language/function-code/10.4.3-1-65-s.js
+language/function-code/10.4.3-1-65gs.js
+language/global-code/decl-lex-configurable-global.js
+language/global-code/decl-lex-restricted-global.js
+language/global-code/script-decl-func-dups.js
+language/global-code/script-decl-func-err-non-configurable.js
+language/global-code/script-decl-func-err-non-extensible.js
+language/global-code/script-decl-func.js
+language/global-code/script-decl-lex-lex.js
+language/global-code/script-decl-lex-restricted-global.js
+language/global-code/script-decl-lex-var.js
+language/global-code/script-decl-lex.js
+language/global-code/script-decl-var-collision.js
+language/global-code/script-decl-var-err.js
+language/global-code/script-decl-var.js
+language/line-terminators/S7.3_A5.4.js
+language/line-terminators/S7.3_A7_T1.js
+language/line-terminators/S7.3_A7_T2.js
+language/line-terminators/S7.3_A7_T3.js
+language/line-terminators/S7.3_A7_T4.js
+language/line-terminators/S7.3_A7_T5.js
+language/line-terminators/S7.3_A7_T6.js
+language/line-terminators/S7.3_A7_T7.js
+language/line-terminators/S7.3_A7_T8.js
+language/literals/numeric/7.8.3-3gs.js
+language/literals/regexp/7.8.5-1.js
+language/literals/regexp/S7.8.5_A1.1_T2.js
+language/literals/regexp/S7.8.5_A1.3_T2.js
+language/literals/regexp/S7.8.5_A1.3_T4.js
+language/literals/regexp/S7.8.5_A1.3_T5.js
+language/literals/regexp/S7.8.5_A1.3_T6.js
+language/literals/regexp/S7.8.5_A1.4_T2.js
+language/literals/regexp/S7.8.5_A1.5_T2.js
+language/literals/regexp/S7.8.5_A1.5_T4.js
+language/literals/regexp/S7.8.5_A1.5_T5.js
+language/literals/regexp/S7.8.5_A1.5_T6.js
+language/literals/regexp/S7.8.5_A2.1_T2.js
+language/literals/regexp/S7.8.5_A2.3_T2.js
+language/literals/regexp/S7.8.5_A2.3_T4.js
+language/literals/regexp/S7.8.5_A2.3_T5.js
+language/literals/regexp/S7.8.5_A2.3_T6.js
+language/literals/regexp/S7.8.5_A2.4_T2.js
+language/literals/regexp/S7.8.5_A2.5_T2.js
+language/literals/regexp/S7.8.5_A2.5_T4.js
+language/literals/regexp/S7.8.5_A2.5_T5.js
+language/literals/regexp/S7.8.5_A2.5_T6.js
+language/literals/regexp/mongolian-vowel-separator-eval.js
+language/literals/regexp/named-groups/forward-reference.js
+language/literals/regexp/named-groups/invalid-lone-surrogate-groupname.js
+language/literals/string/line-separator-eval.js
+language/literals/string/mongolian-vowel-separator-eval.js
+language/literals/string/paragraph-separator-eval.js
+language/module-code/eval-export-cls-semi.js
+language/module-code/eval-export-dflt-cls-named-semi.js
+language/module-code/eval-export-dflt-fun-anon-semi.js
+language/module-code/eval-export-dflt-fun-named-semi.js
+language/module-code/eval-export-dflt-gen-anon-semi.js
+language/module-code/eval-export-dflt-gen-named-semi.js
+language/module-code/eval-export-fun-semi.js
+language/module-code/eval-export-gen-semi.js
+language/module-code/eval-gtbndng-indirect-trlng-comma.js
+language/module-code/eval-gtbndng-indirect-update-as.js
+language/module-code/eval-gtbndng-indirect-update.js
+language/module-code/eval-rqstd-abrupt.js
+language/module-code/eval-this.js
+language/module-code/instn-iee-bndng-cls.js
+language/module-code/instn-iee-bndng-const.js
+language/module-code/instn-iee-bndng-fun.js
+language/module-code/instn-iee-bndng-gen.js
+language/module-code/instn-iee-bndng-let.js
+language/module-code/instn-iee-bndng-var.js
+language/module-code/instn-iee-err-ambiguous-as.js
+language/module-code/instn-iee-err-ambiguous.js
+language/module-code/instn-iee-err-circular-as.js
+language/module-code/instn-iee-err-circular.js
+language/module-code/instn-iee-err-dflt-thru-star-as.js
+language/module-code/instn-iee-err-dflt-thru-star.js
+language/module-code/instn-iee-err-not-found-as.js
+language/module-code/instn-iee-err-not-found.js
+language/module-code/instn-iee-iee-cycle.js
+language/module-code/instn-iee-star-cycle.js
+language/module-code/instn-iee-trlng-comma.js
+language/module-code/instn-local-bndng-export-cls.js
+language/module-code/instn-local-bndng-export-const.js
+language/module-code/instn-local-bndng-export-fun.js
+language/module-code/instn-local-bndng-export-gen.js
+language/module-code/instn-local-bndng-export-let.js
+language/module-code/instn-local-bndng-export-var.js
+language/module-code/instn-named-bndng-cls.js
+language/module-code/instn-named-bndng-const.js
+language/module-code/instn-named-bndng-dflt-named.js
+language/module-code/instn-named-bndng-dflt-star.js
+language/module-code/instn-named-bndng-fun.js
+language/module-code/instn-named-bndng-gen.js
+language/module-code/instn-named-bndng-let.js
+language/module-code/instn-named-bndng-trlng-comma.js
+language/module-code/instn-named-bndng-var.js
+language/module-code/instn-named-err-ambiguous-as.js
+language/module-code/instn-named-err-ambiguous.js
+language/module-code/instn-named-err-dflt-thru-star-as.js
+language/module-code/instn-named-err-not-found-as.js
+language/module-code/instn-named-err-not-found.js
+language/module-code/instn-named-id-name.js
+language/module-code/instn-named-iee-cycle.js
+language/module-code/instn-named-star-cycle.js
+language/module-code/instn-resolve-empty-export.js
+language/module-code/instn-resolve-empty-import.js
+language/module-code/instn-resolve-err-syntax-1.js
+language/module-code/instn-resolve-err-syntax-2.js
+language/module-code/instn-resolve-order-depth.js
+language/module-code/instn-resolve-order-src.js
+language/module-code/instn-same-global.js
+language/module-code/instn-star-ambiguous.js
+language/module-code/instn-star-as-props-dflt-skip.js
+language/module-code/instn-star-binding.js
+language/module-code/instn-star-equality.js
+language/module-code/instn-star-err-not-found.js
+language/module-code/instn-star-id-name.js
+language/module-code/instn-star-iee-cycle.js
+language/module-code/instn-star-props-circular.js
+language/module-code/instn-star-props-dflt-keep-indirect.js
+language/module-code/instn-star-props-dflt-keep-local.js
+language/module-code/instn-star-props-dflt-skip.js
+language/module-code/instn-star-props-nrml.js
+language/module-code/instn-star-star-cycle.js
+language/module-code/namespace/Symbol.iterator.js
+language/module-code/namespace/Symbol.toStringTag.js
+language/module-code/namespace/internals/define-own-property.js
+language/module-code/namespace/internals/delete-exported-init.js
+language/module-code/namespace/internals/delete-exported-uninit.js
+language/module-code/namespace/internals/delete-non-exported.js
+language/module-code/namespace/internals/enumerate-binding-uninit.js
+language/module-code/namespace/internals/get-nested-namespace-dflt-skip.js
+language/module-code/namespace/internals/get-nested-namespace-props-nrml.js
+language/module-code/namespace/internals/get-own-property-str-found-init.js
+language/module-code/namespace/internals/get-own-property-str-found-uninit.js
+language/module-code/namespace/internals/get-own-property-str-not-found.js
+language/module-code/namespace/internals/get-own-property-sym.js
+language/module-code/namespace/internals/get-prototype-of.js
+language/module-code/namespace/internals/get-str-found-init.js
+language/module-code/namespace/internals/get-str-found-uninit.js
+language/module-code/namespace/internals/get-str-initialize.js
+language/module-code/namespace/internals/get-str-not-found.js
+language/module-code/namespace/internals/get-str-update.js
+language/module-code/namespace/internals/get-sym-found.js
+language/module-code/namespace/internals/get-sym-not-found.js
+language/module-code/namespace/internals/has-property-str-found-init.js
+language/module-code/namespace/internals/has-property-str-found-uninit.js
+language/module-code/namespace/internals/has-property-str-not-found.js
+language/module-code/namespace/internals/has-property-sym-found.js
+language/module-code/namespace/internals/has-property-sym-not-found.js
+language/module-code/namespace/internals/is-extensible.js
+language/module-code/namespace/internals/object-hasOwnProperty-binding-uninit.js
+language/module-code/namespace/internals/object-keys-binding-uninit.js
+language/module-code/namespace/internals/object-propertyIsEnumerable-binding-uninit.js
+language/module-code/namespace/internals/own-property-keys-binding-types.js
+language/module-code/namespace/internals/own-property-keys-sort.js
+language/module-code/namespace/internals/prevent-extensions.js
+language/module-code/namespace/internals/set-prototype-of-null.js
+language/module-code/namespace/internals/set-prototype-of.js
+language/module-code/namespace/internals/set.js
+language/module-code/top-level-await/await-expr-regexp.js
+language/module-code/top-level-await/module-import-rejection.js
+language/module-code/top-level-await/syntax/block-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/export-class-decl-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/export-dflt-assign-expr-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/export-lex-decl-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/export-var-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/if-block-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/if-expr-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/top-level-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/try-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/typeof-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/void-await-expr-template-literal.js
+language/module-code/top-level-await/syntax/while-await-expr-template-literal.js
+language/module-code/verify-dfs.js
+language/statementList/eval-block-array-literal-with-item.js
+language/statementList/eval-block-array-literal.js
+language/statementList/eval-block-arrow-function-assignment-expr.js
+language/statementList/eval-block-arrow-function-functionbody.js
+language/statementList/eval-block-block-with-labels.js
+language/statementList/eval-block-block.js
+language/statementList/eval-block-expr-arrow-function-boolean-literal.js
+language/statementList/eval-block-let-declaration.js
+language/statementList/eval-block-regexp-literal-flags.js
+language/statementList/eval-block-regexp-literal.js
+language/statementList/eval-block-with-statment-array-literal-with-item.js
+language/statementList/eval-block-with-statment-array-literal.js
+language/statementList/eval-block-with-statment-arrow-function-assignment-expr.js
+language/statementList/eval-block-with-statment-arrow-function-functionbody.js
+language/statementList/eval-block-with-statment-block-with-labels.js
+language/statementList/eval-block-with-statment-block.js
+language/statementList/eval-block-with-statment-expr-arrow-function-boolean-literal.js
+language/statementList/eval-block-with-statment-let-declaration.js
+language/statementList/eval-block-with-statment-regexp-literal-flags.js
+language/statementList/eval-block-with-statment-regexp-literal.js
+language/statementList/eval-class-array-literal-with-item.js
+language/statementList/eval-class-array-literal.js
+language/statementList/eval-class-arrow-function-assignment-expr.js
+language/statementList/eval-class-arrow-function-functionbody.js
+language/statementList/eval-class-block-with-labels.js
+language/statementList/eval-class-block.js
+language/statementList/eval-class-expr-arrow-function-boolean-literal.js
+language/statementList/eval-class-let-declaration.js
+language/statementList/eval-class-regexp-literal-flags.js
+language/statementList/eval-class-regexp-literal.js
+language/statementList/eval-fn-array-literal-with-item.js
+language/statementList/eval-fn-array-literal.js
+language/statementList/eval-fn-arrow-function-assignment-expr.js
+language/statementList/eval-fn-arrow-function-functionbody.js
+language/statementList/eval-fn-block-with-labels.js
+language/statementList/eval-fn-block.js
+language/statementList/eval-fn-expr-arrow-function-boolean-literal.js
+language/statementList/eval-fn-let-declaration.js
+language/statementList/eval-fn-regexp-literal-flags.js
+language/statementList/eval-fn-regexp-literal.js
+language/statements/async-function/cptn-decl.js
+language/statements/async-function/dflt-params-abrupt.js
+language/statements/async-function/dflt-params-ref-later.js
+language/statements/async-function/dflt-params-ref-self.js
+language/statements/async-function/dflt-params-trailing-comma.js
+language/statements/async-function/evaluation-default-that-throws.js
+language/statements/async-function/evaluation-this-value-passed.js
+language/statements/async-function/params-trailing-comma-multiple.js
+language/statements/async-function/params-trailing-comma-single.js
+language/statements/async-function/syntax-declaration-line-terminators-allowed.js
+language/statements/block/tco-stmt-list.js
+language/statements/block/tco-stmt.js
+language/statements/async-generator/dflt-params-ref-later.js
+language/statements/async-generator/dflt-params-ref-self.js
+language/statements/async-generator/return-undefined-implicit-and-explicit.js
+language/statements/async-generator/yield-return-then-getter-ticks.js
+language/statements/async-generator/yield-star-return-then-getter-ticks.js
+language/statements/break/S12.8_A7.js
+language/statements/class/accessor-name-inst/computed-err-to-prop-key.js
+language/statements/class/accessor-name-inst/computed.js
+language/statements/class/accessor-name-static/computed-err-to-prop-key.js
+language/statements/class/accessor-name-static/computed.js
+language/statements/class/async-gen-method-static/dflt-params-ref-later.js
+language/statements/class/async-gen-method-static/dflt-params-ref-self.js
+language/statements/class/async-gen-method/dflt-params-ref-later.js
+language/statements/class/async-gen-method/dflt-params-ref-self.js
+language/statements/class/async-method-static/dflt-params-abrupt.js
+language/statements/class/async-method-static/dflt-params-ref-later.js
+language/statements/class/async-method-static/dflt-params-ref-self.js
+language/statements/class/async-method/dflt-params-abrupt.js
+language/statements/class/async-method/dflt-params-ref-later.js
+language/statements/class/async-method/dflt-params-ref-self.js
+language/statements/class/cptn-decl.js
+language/statements/class/elements/abrupt-completition-on-field-initializer.js
+language/statements/class/elements/after-same-line-gen-computed-symbol-names.js
+language/statements/class/elements/after-same-line-method-computed-symbol-names.js
+language/statements/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
+language/statements/class/elements/after-same-line-static-async-method-computed-symbol-names.js
+language/statements/class/elements/after-same-line-static-gen-computed-symbol-names.js
+language/statements/class/elements/after-same-line-static-method-computed-symbol-names.js
+language/statements/class/elements/class-field-is-observable-by-proxy.js
+language/statements/class/elements/computed-name-toprimitive-symbol.js
+language/statements/class/elements/computed-name-toprimitive.js
+language/statements/class/elements/derived-cls-direct-eval-contains-superproperty-1.js
+language/statements/class/elements/derived-cls-direct-eval-contains-superproperty-2.js
+language/statements/class/elements/derived-cls-direct-eval-err-contains-supercall-1.js
+language/statements/class/elements/derived-cls-direct-eval-err-contains-supercall-2.js
+language/statements/class/elements/derived-cls-direct-eval-err-contains-supercall.js
+language/statements/class/elements/derived-cls-indirect-eval-contains-superproperty-1.js
+language/statements/class/elements/derived-cls-indirect-eval-contains-superproperty-2.js
+language/statements/class/elements/derived-cls-indirect-eval-err-contains-supercall-1.js
+language/statements/class/elements/derived-cls-indirect-eval-err-contains-supercall-2.js
+language/statements/class/elements/derived-cls-indirect-eval-err-contains-supercall.js
+language/statements/class/elements/direct-eval-err-contains-arguments.js
+language/statements/class/elements/direct-eval-err-contains-newtarget.js
+language/statements/class/elements/evaluation-error/computed-name-referenceerror.js
+language/statements/class/elements/evaluation-error/computed-name-toprimitive-err.js
+language/statements/class/elements/evaluation-error/computed-name-toprimitive-returns-noncallable.js
+language/statements/class/elements/evaluation-error/computed-name-toprimitive-returns-nonobject.js
+language/statements/class/elements/evaluation-error/computed-name-tostring-err.js
+language/statements/class/elements/evaluation-error/computed-name-valueof-err.js
+language/statements/class/elements/fields-computed-name-propname-constructor.js
+language/statements/class/elements/fields-computed-name-static-computed-var-propname-constructor.js
+language/statements/class/elements/fields-computed-name-static-computed-var-propname-prototype.js
+language/statements/class/elements/indirect-eval-err-contains-arguments.js
+language/statements/class/elements/indirect-eval-err-contains-newtarget.js
+language/statements/class/elements/init-value-defined-after-class.js
+language/statements/class/elements/multiple-definitions-computed-symbol-names.js
+language/statements/class/elements/multiple-stacked-definitions-computed-symbol-names.js
+language/statements/class/elements/new-no-sc-line-method-computed-symbol-names.js
+language/statements/class/elements/new-sc-line-gen-computed-symbol-names.js
+language/statements/class/elements/new-sc-line-method-computed-symbol-names.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-1.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-2.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-3.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-6.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-7.js
+language/statements/class/elements/privatename-not-valid-eval-earlyerr-8.js
+language/statements/class/elements/public-class-field-initialization-is-visible-to-proxy.js
+language/statements/class/elements/public-class-field-initialization-on-super-class-with-setter.js
+language/statements/class/elements/redeclaration-symbol.js
+language/statements/class/elements/regular-definitions-computed-symbol-names.js
+language/statements/class/elements/same-line-async-gen-computed-symbol-names.js
+language/statements/class/elements/same-line-async-method-computed-symbol-names.js
+language/statements/class/elements/same-line-gen-computed-symbol-names.js
+language/statements/class/elements/same-line-method-computed-symbol-names.js
+language/statements/class/elements/static-field-init-this-inside-arrow-function.js
+language/statements/class/elements/static-field-init-with-this.js
+language/statements/class/elements/static-field-redeclaration.js
+language/statements/class/elements/static-fielddefinition-initializer-abrupt-completion.js
+language/statements/class/elements/wrapped-in-sc-computed-symbol-names.js
+language/statements/class/gen-method-static/dflt-params-ref-later.js
+language/statements/class/gen-method-static/dflt-params-ref-self.js
+language/statements/class/gen-method/dflt-params-ref-later.js
+language/statements/class/gen-method/dflt-params-ref-self.js
+language/statements/class/method-static/dflt-params-ref-later.js
+language/statements/class/method-static/dflt-params-ref-self.js
+language/statements/class/method/dflt-params-ref-later.js
+language/statements/class/method/dflt-params-ref-self.js
+language/statements/class/subclass/builtin-objects/Function/instance-length.js
+language/statements/class/subclass/builtin-objects/Function/instance-name.js
+language/statements/class/subclass/builtin-objects/Function/regular-subclassing.js
+language/statements/class/subclass/builtin-objects/GeneratorFunction/instance-length.js
+language/statements/class/subclass/builtin-objects/GeneratorFunction/instance-name.js
+language/statements/class/subclass/builtin-objects/GeneratorFunction/instance-prototype.js
+language/statements/class/subclass/builtin-objects/GeneratorFunction/regular-subclassing.js
+language/statements/class/subclass/builtin-objects/GeneratorFunction/super-must-be-called.js
+language/statements/class/subclass/default-constructor-spread-override.js
+language/statements/class/subclass/superclass-async-function.js
+language/statements/class/subclass/superclass-bound-function.js
+language/statements/const/cptn-value.js
+language/statements/continue/S12.7_A7.js
+language/statements/do-while/S12.6.1_A3.js
+language/statements/do-while/S12.6.1_A5.js
+language/statements/do-while/S12.6.1_A7.js
+language/statements/do-while/S12.6.1_A8.js
+language/statements/do-while/cptn-abrupt-empty.js
+language/statements/do-while/cptn-normal.js
+language/statements/do-while/tco-body.js
+language/statements/empty/cptn-value.js
+language/statements/expression/S12.4_A2_T1.js
+language/statements/expression/S12.4_A2_T2.js
+language/statements/for-await-of/async-func-decl-dstr-obj-rest-number.js
+language/statements/for-await-of/async-func-decl-dstr-obj-rest-str-val.js
+language/statements/for-await-of/async-func-decl-dstr-obj-rest-symbol-val.js
+language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-rtrn-close-null.js
+language/statements/for-await-of/async-gen-decl-dstr-obj-rest-number.js
+language/statements/for-await-of/async-gen-decl-dstr-obj-rest-str-val.js
+language/statements/for-await-of/async-gen-decl-dstr-obj-rest-symbol-val.js
+language/statements/for-await-of/iterator-close-non-throw-get-method-abrupt.js
+language/statements/for-await-of/iterator-close-non-throw-get-method-is-null.js
+language/statements/for-await-of/ticks-with-async-iter-resolved-promise-and-constructor-lookup-two.js
+language/statements/for-await-of/ticks-with-async-iter-resolved-promise-and-constructor-lookup.js
+language/statements/for-await-of/ticks-with-sync-iter-resolved-promise-and-constructor-lookup.js
+language/statements/for-in/S12.6.4_A3.1.js
+language/statements/for-in/S12.6.4_A3.js
+language/statements/for-in/S12.6.4_A4.1.js
+language/statements/for-in/S12.6.4_A4.js
+language/statements/for-in/cptn-decl-abrupt-empty.js
+language/statements/for-in/cptn-decl-itr.js
+language/statements/for-in/cptn-decl-skip-itr.js
+language/statements/for-in/cptn-decl-zero-itr.js
+language/statements/for-in/cptn-expr-abrupt-empty.js
+language/statements/for-in/cptn-expr-itr.js
+language/statements/for-in/cptn-expr-skip-itr.js
+language/statements/for-in/cptn-expr-zero-itr.js
+language/statements/for-in/order-after-define-property.js
+language/statements/for-in/scope-body-lex-open.js
+language/statements/for-in/scope-head-lex-close.js
+language/statements/for-in/scope-head-lex-open.js
+language/statements/for-of/cptn-decl-abrupt-empty.js
+language/statements/for-of/cptn-decl-itr.js
+language/statements/for-of/cptn-decl-no-itr.js
+language/statements/for-of/cptn-expr-abrupt-empty.js
+language/statements/for-of/cptn-expr-itr.js
+language/statements/for-of/cptn-expr-no-itr.js
+language/statements/for-of/dstr/array-elem-iter-rtrn-close-err.js
+language/statements/for-of/dstr/array-elem-iter-rtrn-close-null.js
+language/statements/for-of/dstr/array-elem-iter-rtrn-close.js
+language/statements/for-of/dstr/array-elem-trlg-iter-list-rtrn-close-err.js
+language/statements/for-of/dstr/array-elem-trlg-iter-list-rtrn-close-null.js
+language/statements/for-of/dstr/array-elem-trlg-iter-list-rtrn-close.js
+language/statements/for-of/dstr/array-elem-trlg-iter-rest-rtrn-close-err.js
+language/statements/for-of/dstr/array-elem-trlg-iter-rest-rtrn-close-null.js
+language/statements/for-of/dstr/array-elem-trlg-iter-rest-rtrn-close.js
+language/statements/for-of/dstr/array-rest-iter-rtrn-close-err.js
+language/statements/for-of/dstr/array-rest-iter-rtrn-close-null.js
+language/statements/for-of/dstr/array-rest-iter-rtrn-close.js
+language/statements/for-of/dstr/array-rest-put-const.js
+language/statements/for-of/dstr/array-rest-put-let.js
+language/statements/for-of/dstr/obj-rest-computed-property.js
+language/statements/for-of/dstr/obj-rest-number.js
+language/statements/for-of/dstr/obj-rest-order.js
+language/statements/for-of/dstr/obj-rest-put-const.js
+language/statements/for-of/dstr/obj-rest-str-val.js
+language/statements/for-of/dstr/obj-rest-symbol-val.js
+language/statements/for-of/iterator-close-throw-get-method-abrupt.js
+language/statements/for-of/iterator-close-throw-get-method-non-callable.js
+language/statements/for-of/scope-body-lex-open.js
+language/statements/for-of/scope-head-lex-close.js
+language/statements/for/S12.6.3_A5.js
+language/statements/for/cptn-decl-expr-iter.js
+language/statements/for/cptn-decl-expr-no-iter.js
+language/statements/for/cptn-expr-expr-iter.js
+language/statements/for/cptn-expr-expr-no-iter.js
+language/statements/for/head-init-expr-check-empty-inc-empty-completion.js
+language/statements/for/head-init-var-check-empty-inc-empty-completion.js
+language/statements/for/tco-const-body.js
+language/statements/for/tco-let-body.js
+language/statements/for/tco-lhs-body.js
+language/statements/for/tco-var-body.js
+language/statements/function/13.0-12-s.js
+language/statements/function/13.0-8-s.js
+language/statements/function/13.0_4-17gs.js
+language/statements/function/13.1-2-s.js
+language/statements/function/13.1-4-s.js
+language/statements/function/13.2-10-s.js
+language/statements/function/13.2-11-s.js
+language/statements/function/13.2-12-s.js
+language/statements/function/13.2-13-s.js
+language/statements/function/13.2-14-s.js
+language/statements/function/13.2-15-s.js
+language/statements/function/13.2-16-s.js
+language/statements/function/13.2-17-s.js
+language/statements/function/13.2-18-s.js
+language/statements/function/13.2-19-s.js
+language/statements/function/S13.2.2_A8_T3.js
+language/statements/function/cptn-decl.js
+language/statements/function/dflt-params-ref-later.js
+language/statements/function/dflt-params-ref-self.js
+language/statements/function/name-unicode.js
+language/statements/generators/cptn-decl.js
+language/statements/generators/dflt-params-ref-later.js
+language/statements/generators/dflt-params-ref-self.js
+language/statements/if/S12.5_A2.js
+language/statements/if/cptn-else-false-abrupt-empty.js
+language/statements/if/cptn-else-false-nrml.js
+language/statements/if/cptn-else-true-abrupt-empty.js
+language/statements/if/cptn-else-true-nrml.js
+language/statements/if/cptn-empty-statement.js
+language/statements/if/cptn-no-else-false.js
+language/statements/if/cptn-no-else-true-abrupt-empty.js
+language/statements/if/cptn-no-else-true-nrml.js
+language/statements/if/tco-else-body.js
+language/statements/if/tco-if-body.js
+language/statements/labeled/cptn-break.js
+language/statements/labeled/cptn-nrml.js
+language/statements/labeled/tco.js
+language/statements/let/cptn-value.js
+language/statements/return/tco.js
+language/statements/switch/cptn-a-abrupt-empty.js
+language/statements/switch/cptn-a-fall-thru-abrupt-empty.js
+language/statements/switch/cptn-a-fall-thru-nrml.js
+language/statements/switch/cptn-abrupt-empty.js
+language/statements/switch/cptn-b-abrupt-empty.js
+language/statements/switch/cptn-b-fall-thru-abrupt-empty.js
+language/statements/switch/cptn-b-fall-thru-nrml.js
+language/statements/switch/cptn-b-final.js
+language/statements/switch/cptn-dflt-abrupt-empty.js
+language/statements/switch/cptn-dflt-b-abrupt-empty.js
+language/statements/switch/cptn-dflt-b-fall-thru-abrupt-empty.js
+language/statements/switch/cptn-dflt-b-fall-thru-nrml.js
+language/statements/switch/cptn-dflt-b-final.js
+language/statements/switch/cptn-dflt-fall-thru-abrupt-empty.js
+language/statements/switch/cptn-dflt-fall-thru-nrml.js
+language/statements/switch/cptn-dflt-final.js
+language/statements/switch/cptn-no-dflt-match-abrupt-empty.js
+language/statements/switch/cptn-no-dflt-match-fall-thru-abrupt-empty.js
+language/statements/switch/cptn-no-dflt-match-fall-thru-nrml.js
+language/statements/switch/cptn-no-dflt-match-final.js
+language/statements/switch/cptn-no-dflt-no-match.js
+language/statements/switch/scope-lex-close-dflt.js
+language/statements/switch/scope-lex-open-dflt.js
+language/statements/switch/tco-case-body-dflt.js
+language/statements/switch/tco-case-body.js
+language/statements/switch/tco-dftl-body.js
+language/statements/try/catch-parameter-boundnames-restriction-arguments-eval-throws.js
+language/statements/try/catch-parameter-boundnames-restriction-eval-eval-throws.js
+language/statements/try/cptn-catch-empty-break.js
+language/statements/try/cptn-catch-empty-continue.js
+language/statements/try/cptn-catch-finally-empty-break.js
+language/statements/try/cptn-catch-finally-empty-continue.js
+language/statements/try/cptn-catch.js
+language/statements/try/cptn-finally-empty-break.js
+language/statements/try/cptn-finally-empty-continue.js
+language/statements/try/cptn-finally-from-catch.js
+language/statements/try/cptn-finally-skip-catch.js
+language/statements/try/cptn-finally-wo-catch.js
+language/statements/try/cptn-try.js
+language/statements/try/tco-catch-finally.js
+language/statements/try/tco-catch.js
+language/statements/try/tco-catch.js
+language/statements/try/tco-finally.js
+language/statements/variable/12.2.1-10-s.js
+language/statements/variable/12.2.1-16-s.js
+language/statements/variable/12.2.1-17-s.js
+language/statements/variable/12.2.1-18-s.js
+language/statements/variable/12.2.1-19-s.js
+language/statements/variable/12.2.1-2-s.js
+language/statements/variable/12.2.1-20-s.js
+language/statements/variable/12.2.1-21-s.js
+language/statements/variable/12.2.1-22-s.js
+language/statements/variable/12.2.1-3-s.js
+language/statements/variable/12.2.1-4-s.js
+language/statements/variable/12.2.1-5-s.js
+language/statements/variable/12.2.1-6-s.js
+language/statements/variable/12.2.1-7-s.js
+language/statements/variable/12.2.1-8-s.js
+language/statements/variable/12.2.1-9-s.js
+language/statements/variable/cptn-value.js
+language/statements/while/S12.6.2_A3.js
+language/statements/while/S12.6.2_A5.js
+language/statements/while/S12.6.2_A7.js
+language/statements/while/S12.6.2_A8.js
+language/statements/while/cptn-abrupt-empty.js
+language/statements/while/cptn-iter.js
+language/statements/while/cptn-no-iter.js
+language/statements/while/tco-body.js
+language/statements/with/12.10.1-10-s.js
+language/statements/with/12.10.1-5-s.js
+language/types/reference/8.7.2-1-s.js
+language/types/reference/get-value-prop-base-primitive-realm.js
+language/types/reference/put-value-prop-base-primitive-realm.js
+language/types/string/S8.4_A7.1.js
+language/types/string/S8.4_A7.2.js
+language/types/string/S8.4_A7.3.js
+language/types/string/S8.4_A7.4.js
+language/white-space/comment-multi-form-feed.js
+language/white-space/comment-multi-horizontal-tab.js
+language/white-space/comment-multi-nbsp.js
+language/white-space/comment-multi-space.js
+language/white-space/comment-multi-vertical-tab.js
+language/white-space/comment-single-form-feed.js
+language/white-space/comment-single-horizontal-tab.js
+language/white-space/comment-single-nbsp.js
+language/white-space/comment-single-space.js
+language/white-space/comment-single-vertical-tab.js
+language/white-space/mongolian-vowel-separator-eval.js
+language/white-space/string-form-feed.js
+language/white-space/string-horizontal-tab.js
+language/white-space/string-nbsp.js
+language/white-space/string-space.js
+language/white-space/string-vertical-tab.js
diff --git a/es2panda/test/test262util.py b/es2panda/test/test262util.py
new file mode 100644
index 0000000000000000000000000000000000000000..5351b9ed8e3094caede27b3d5378c447e6686169
--- /dev/null
+++ b/es2panda/test/test262util.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from glob import glob
+from os import path
+import os
+import re
+import shutil
+import subprocess
+
+
+class Test262Util:
+    def __init__(self):
+        self.header = re.compile(
+            r"\/\*---(?P<header>.+)---\*\/", re.DOTALL)
+        self.includes = re.compile(r"includes:\s+\[(?P<includes>.+)\]")
+        self.includes2 = re.compile(r"includes:(?P<includes>(\s+-[^-].+)+)")
+        self.flags = re.compile(r"flags:\s+\[(?P<flags>.+)\]")
+        self.negative = re.compile(
+            r"negative:.*phase:\s+(?P<phase>\w+).*type:\s+(?P<type>\w+)",
+            re.DOTALL)
+        self.async_ok = re.compile(r"Test262:AsyncTestComplete")
+
+    def generate(self, revision, build_dir, harness_path, show_progress):
+        dest_path = path.join(build_dir, 'test262')
+        stamp_file = path.join(dest_path, 'test262.stamp')
+
+        if path.isfile(stamp_file):
+            return dest_path
+
+        test262_path = path.join(path.sep, 'tmp', 'test262-%s' % revision)
+
+        if not path.exists(test262_path):
+            archive_file = path.join(path.sep, 'tmp', 'test262.zip')
+
+            print("Downloading test262")
+
+            cmd = ['wget', '-q', '-O', archive_file,
+                   'https://github.com/tc39/test262/archive/%s.zip' % revision]
+
+            if show_progress:
+                cmd.append('--show-progress')
+
+            return_code = subprocess.call(cmd)
+
+            if return_code:
+                raise Exception('Downloading test262 repository failed.')
+
+            print("Extracting archive")
+            if path.isdir(test262_path):
+                shutil.rmtree(test262_path)
+
+            return_code = subprocess.call(
+                ['unzip', '-q', '-d', path.join(path.sep, 'tmp'), archive_file])
+
+            if return_code:
+                raise Exception(
+                    'Failed to unzip test262 repository')
+
+            os.remove(archive_file)
+
+        print("Generating tests")
+        src_path = path.join(test262_path, 'test')
+
+        glob_expression = path.join(src_path, "**/*.js")
+        files = glob(glob_expression, recursive=True)
+        files = list(filter(lambda f: not f.endswith("FIXTURE.js"), files))
+
+        with open(harness_path, 'r') as fp:
+            harness = fp.read()
+
+        harness = harness.replace('$SOURCE', '`%s`' % harness)
+
+        for src_file in files:
+            dest_file = src_file.replace(src_path, dest_path)
+            os.makedirs(path.dirname(dest_file), exist_ok=True)
+            self.create_file(src_file, dest_file, harness, test262_path)
+
+        with open(stamp_file, 'w') as fp:
+            pass
+
+        return dest_path
+
+    def create_file(self, input_file, output_file, harness, test262_dir):
+        with open(input_file, 'r') as fp:
+            input_str = fp.read()
+
+        header = self.get_header(input_str)
+        desc = self.parse_descriptor(header)
+
+        out_str = header
+        out_str += "\n"
+        out_str += harness
+
+        for include in desc['includes']:
+            out_str += "//------------ %s start ------------\n" % include
+            with open(path.join(test262_dir, 'harness', include), 'r') as fp:
+                harness_str = fp.read()
+            out_str += harness_str
+            out_str += "//------------ %s end ------------\n" % include
+            out_str += "\n"
+
+        out_str += input_str
+        with open(output_file, 'w') as o:
+            o.write(out_str)
+
+    def get_header(self, content):
+        header_comment = self.header.search(content)
+        assert header_comment
+        return header_comment.group(0)
+
+    def parse_descriptor(self, header):
+        match = self.includes.search(header)
+        includes = list(map(lambda e: e.strip(), match.group(
+            'includes').split(','))) if match else []
+
+        match = self.includes2.search(header)
+        includes += list(map(lambda e: e.strip(), match.group(
+            'includes').split('-')))[1:] if match else []
+
+        includes.extend(['assert.js', 'sta.js'])
+
+        match = self.flags.search(header)
+        flags = list(map(lambda e: e.strip(),
+                         match.group('flags').split(','))) if match else []
+
+        if 'async' in flags:
+            includes.extend(['doneprintHandle.js'])
+
+        match = self.negative.search(header)
+        negative_phase = match.group('phase') if match else 'pass'
+        negative_type = match.group('type') if match else ''
+
+        # negative_phase: pass, parse, resolution, runtime
+        return {
+            'flags': flags,
+            'negative_phase': negative_phase,
+            'negative_type': negative_type,
+            'includes': includes,
+        }
+
+    @staticmethod
+    def validate_parse_result(return_code, std_err, desc, out):
+        is_negative = (desc['negative_phase'] == 'parse')
+
+        if return_code == 0:  # passed
+            if is_negative:
+                return False, False  # negative test passed
+
+            return True, True  # positive test passed
+
+        if return_code == 1:  # failed
+            return is_negative and (desc['negative_type'] in out), False
+
+        return False, False  # abnormal
+
+    def validate_runtime_result(self, return_code, std_err, desc, out):
+        is_negative = (desc['negative_phase'] == 'runtime') or (
+            desc['negative_phase'] == 'resolution')
+
+        if return_code == 0:  # passed
+            if is_negative:
+                return False  # negative test passed
+
+            passed = (len(std_err) == 0)
+            if 'async' in desc['flags']:
+                passed = passed and bool(self.async_ok.match(out))
+            return passed  # positive test passed?
+
+        if return_code == 1:  # failed
+            return is_negative and (desc['negative_type'] in std_err)
+
+        return False  # abnormal
diff --git a/es2panda/typescript/checker.cpp b/es2panda/typescript/checker.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..71be1ad7d6ee73574f6597075110affee7e6ee25
--- /dev/null
+++ b/es2panda/typescript/checker.cpp
@@ -0,0 +1,258 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "checker.h"
+
+#include <ir/expression.h>
+#include <ir/statements/blockStatement.h>
+#include <parser/program/program.h>
+#include <util/helpers.h>
+#include <binder/binder.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+#include <es2panda.h>
+
+#include <cstdint>
+#include <initializer_list>
+#include <memory>
+
+namespace panda::es2panda::checker {
+
+Checker::Checker(ArenaAllocator *allocator, binder::Binder *binder)
+    : allocator_(allocator),
+      binder_(binder),
+      rootNode_(binder->TopScope()->Node()->AsBlockStatement()),
+      scope_(binder->TopScope())
+{
+    scopeStack_.push_back(scope_);
+    globalTypes_ = allocator_->New<GlobalTypesHolder>(allocator_);
+    relation_ = allocator_->New<TypeRelation>(this);
+    status_ = CheckerStatus::NO_OPTS;
+}
+
+void Checker::StartChecker()
+{
+    ASSERT(rootNode_->IsProgram());
+    rootNode_->Check(this);
+}
+
+binder::Scope *Checker::Scope() const
+{
+    return scope_;
+}
+
+void Checker::ThrowTypeError(std::initializer_list<TypeErrorMessageElement> list, const lexer::SourcePosition &pos)
+{
+    std::stringstream ss;
+
+    for (const auto &it : list) {
+        if (std::holds_alternative<char *>(it)) {
+            ss << std::get<char *>(it);
+        } else if (std::holds_alternative<util::StringView>(it)) {
+            ss << std::get<util::StringView>(it);
+        } else if (std::holds_alternative<lexer::TokenType>(it)) {
+            ss << TokenToString(std::get<lexer::TokenType>(it));
+        } else if (std::holds_alternative<const Type *>(it)) {
+            std::get<const Type *>(it)->ToString(ss);
+        } else if (std::holds_alternative<AsSrc>(it)) {
+            std::get<AsSrc>(it).GetType()->ToStringAsSrc(ss);
+        } else if (std::holds_alternative<size_t>(it)) {
+            ss << std::to_string(std::get<size_t>(it));
+        } else {
+            UNREACHABLE();
+        }
+    }
+
+    std::string err = ss.str();
+    ThrowTypeError(err, pos);
+}
+
+void Checker::ThrowTypeError(std::string_view message, const lexer::SourcePosition &pos)
+{
+    lexer::LineIndex index(binder_->Program()->SourceCode());
+    lexer::SourceLocation loc = index.GetLocation(pos);
+
+    throw Error {ErrorType::TYPE, message, loc.line, loc.col};
+}
+
+Type *Checker::GlobalNumberType()
+{
+    return globalTypes_->GlobalNumberType();
+}
+
+Type *Checker::GlobalAnyType()
+{
+    return globalTypes_->GlobalAnyType();
+}
+
+Type *Checker::GlobalStringType()
+{
+    return globalTypes_->GlobalStringType();
+}
+
+Type *Checker::GlobalBooleanType()
+{
+    return globalTypes_->GlobalBooleanType();
+}
+
+Type *Checker::GlobalVoidType()
+{
+    return globalTypes_->GlobalVoidType();
+}
+
+Type *Checker::GlobalNullType()
+{
+    return globalTypes_->GlobalNullType();
+}
+
+Type *Checker::GlobalUndefinedType()
+{
+    return globalTypes_->GlobalUndefinedType();
+}
+
+Type *Checker::GlobalUnknownType()
+{
+    return globalTypes_->GlobalUnknownType();
+}
+
+Type *Checker::GlobalNeverType()
+{
+    return globalTypes_->GlobalNeverType();
+}
+
+Type *Checker::GlobalNonPrimitiveType()
+{
+    return globalTypes_->GlobalNonPrimitiveType();
+}
+
+Type *Checker::GlobalBigintType()
+{
+    return globalTypes_->GlobalBigintType();
+}
+
+Type *Checker::GlobalFalseType()
+{
+    return globalTypes_->GlobalFalseType();
+}
+
+Type *Checker::GlobalTrueType()
+{
+    return globalTypes_->GlobalTrueType();
+}
+
+Type *Checker::GlobalNumberOrBigintType()
+{
+    return globalTypes_->GlobalNumberOrBigintType();
+}
+
+Type *Checker::GlobalStringOrNumberType()
+{
+    return globalTypes_->GlobalStringOrNumberType();
+}
+
+Type *Checker::GlobalZeroType()
+{
+    return globalTypes_->GlobalZeroType();
+}
+
+Type *Checker::GlobalEmptyStringType()
+{
+    return globalTypes_->GlobalEmptyStringType();
+}
+
+Type *Checker::GlobalZeroBigintType()
+{
+    return globalTypes_->GlobalZeroBigintType();
+}
+
+Type *Checker::GlobalPrimitiveType()
+{
+    return globalTypes_->GlobalPrimitiveType();
+}
+
+Type *Checker::GlobalEmptyTupleType()
+{
+    return globalTypes_->GlobalEmptyTupleType();
+}
+
+Type *Checker::GlobalEmptyObjectType()
+{
+    return globalTypes_->GlobalEmptyObjectType();
+}
+
+NumberLiteralPool &Checker::NumberLiteralMap()
+{
+    return numberLiteralMap_;
+}
+
+StringLiteralPool &Checker::StringLiteralMap()
+{
+    return stringLiteralMap_;
+}
+
+StringLiteralPool &Checker::BigintLiteralMap()
+{
+    return bigintLiteralMap_;
+}
+
+TypeRelation *Checker::Relation()
+{
+    return relation_;
+}
+
+RelationHolder &Checker::IdenticalResults()
+{
+    return identicalResults_;
+}
+
+RelationHolder &Checker::AssignableResults()
+{
+    return assignableResults_;
+}
+
+RelationHolder &Checker::ComparableResults()
+{
+    return comparableResults_;
+}
+
+std::unordered_set<const ir::AstNode *> &Checker::TypeStack()
+{
+    return typeStack_;
+}
+
+std::unordered_map<const ir::AstNode *, Type *> &Checker::NodeCache()
+{
+    return nodeCache_;
+}
+
+CheckerStatus Checker::Status()
+{
+    return status_;
+}
+
+Type *Checker::CheckTypeCached(const ir::Expression *expr)
+{
+    auto res = nodeCache_.find(expr);
+    if (res != nodeCache_.end()) {
+        return res->second;
+    }
+
+    Type *returnType = expr->Check(this);
+    nodeCache_.insert({expr, returnType});
+
+    return returnType;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/checker.h b/es2panda/typescript/checker.h
new file mode 100644
index 0000000000000000000000000000000000000000..7063aa6dcd4a8ded76bbf09f0c78dfd4333935a4
--- /dev/null
+++ b/es2panda/typescript/checker.h
@@ -0,0 +1,519 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_CHECKER_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_CHECKER_H
+
+#include <binder/enumMemberResult.h>
+#include <typescript/types/globalTypesHolder.h>
+#include <typescript/types/typeRelation.h>
+#include <typescript/types/types.h>
+#include <macros.h>
+#include <util/enumbitops.h>
+#include <util/ustring.h>
+
+#include <cstdint>
+#include <initializer_list>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace panda::es2panda::binder {
+class Binder;
+class Decl;
+class EnumVariable;
+class FunctionDecl;
+class LocalVariable;
+class Scope;
+class Variable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::ir {
+class AstNode;
+class SpreadElement;
+class AssignmentExpression;
+class Property;
+class Expression;
+class ScriptFunction;
+class UnaryExpression;
+class BinaryExpression;
+class Identifier;
+class MemberExpression;
+class TSEnumDeclaration;
+class TSInterfaceDeclaration;
+class ObjectExpression;
+class TSArrayType;
+class TSUnionType;
+class TSFunctionType;
+class TSConstructorType;
+class TSTypeLiteral;
+class TSTypeReference;
+class TSQualifiedName;
+class TSIndexedAccessType;
+class TSInterfaceHeritage;
+class TSTypeQuery;
+class TSTupleType;
+class ArrayExpression;
+class Statement;
+class TSTypeParameterDeclaration;
+class TSTypeParameterInstantiation;
+class BlockStatement;
+class VariableDeclaration;
+class IfStatement;
+class DoWhileStatement;
+class WhileStatement;
+class ForUpdateStatement;
+class ForInStatement;
+class ForOfStatement;
+class ReturnStatement;
+class SwitchStatement;
+class LabelledStatement;
+class ThrowStatement;
+class TryStatement;
+class TSTypeAliasDeclaration;
+class TSAsExpression;
+class ThisExpression;
+class NewExpression;
+class FunctionExpression;
+class AwaitExpression;
+class UpdateExpression;
+class ConditionalExpression;
+class YieldExpression;
+class ArrowFunctionExpression;
+class TemplateLiteral;
+class TaggedTemplateExpression;
+class TSIndexSignature;
+class TSSignatureDeclaration;
+class TSPropertySignature;
+class TSMethodSignature;
+class ChainExpression;
+
+enum class AstNodeType;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::checker {
+
+using StringLiteralPool = std::unordered_map<util::StringView, Type *>;
+using NumberLiteralPool = std::unordered_map<double, Type *>;
+using FunctionParamsResolveResult = std::variant<std::vector<binder::LocalVariable *> &, bool>;
+using InterfacePropertyMap = std::unordered_map<util::StringView, std::pair<binder::LocalVariable *, InterfaceType *>>;
+using TypeOrNode = std::variant<Type *, const ir::AstNode *>;
+using IndexInfoTypePair = std::pair<Type *, Type *>;
+using PropertyMap = std::unordered_map<util::StringView, binder::LocalVariable *>;
+
+enum class DestructuringType {
+    NO_DESTRUCTURING,
+    ARRAY_DESTRUCTURING,
+    OBJECT_DESTRUCTURING,
+};
+
+class ObjectLiteralElaborationData {
+public:
+    ObjectLiteralElaborationData() = default;
+    ~ObjectLiteralElaborationData() = default;
+    NO_COPY_SEMANTIC(ObjectLiteralElaborationData);
+    NO_MOVE_SEMANTIC(ObjectLiteralElaborationData);
+
+    ObjectDescriptor *desc {};
+    std::vector<Type *> stringIndexTypes {};
+    Type *numberInfosType {};
+    Type *stringInfosType {};
+    std::vector<const ir::SpreadElement *> spreads {};
+    std::unordered_map<uint32_t, ObjectType *> potentialObjectTypes {};
+};
+
+class ObjectLiteralPropertyInfo {
+public:
+    ObjectLiteralPropertyInfo() = default;
+    ~ObjectLiteralPropertyInfo() = default;
+    NO_COPY_SEMANTIC(ObjectLiteralPropertyInfo);
+    DEFAULT_MOVE_SEMANTIC(ObjectLiteralPropertyInfo);
+
+    util::StringView propName {};
+    Type *propType {};
+    bool handleNextProp {};
+};
+
+class FunctionParameterInfo {
+public:
+    FunctionParameterInfo() = default;
+    ~FunctionParameterInfo() = default;
+    NO_COPY_SEMANTIC(FunctionParameterInfo);
+    DEFAULT_MOVE_SEMANTIC(FunctionParameterInfo);
+
+    const ir::Expression *typeAnnotation {};
+    const ir::Expression *initNode {};
+    const ir::Expression *bindingNode {};
+    Type *initType {};
+    Type *restType {};
+    DestructuringType destructuringType {DestructuringType::NO_DESTRUCTURING};
+    bool optionalParam {};
+    util::StringView paramName {};
+};
+
+enum class CheckerStatus {
+    NO_OPTS = 0,
+    FORCE_TUPLE = 1 << 0,
+};
+
+DEFINE_BITOPS(CheckerStatus)
+
+enum class VariableBindingContext {
+    REGULAR,
+    FOR_IN,
+    FOR_OF,
+};
+
+class Checker {
+public:
+    explicit Checker(ArenaAllocator *allocator, binder::Binder *binder);
+    ~Checker() = default;
+    NO_COPY_SEMANTIC(Checker);
+    NO_MOVE_SEMANTIC(Checker);
+
+    void StartChecker();
+
+    ArenaAllocator *Allocator() const
+    {
+        return allocator_;
+    }
+
+    binder::Binder *Binder()
+    {
+        return binder_;
+    }
+
+    binder::Scope *Scope() const;
+
+    [[noreturn]] void ThrowTypeError(std::string_view message, const lexer::SourcePosition &pos);
+    [[noreturn]] void ThrowTypeError(std::initializer_list<TypeErrorMessageElement> list,
+                                     const lexer::SourcePosition &pos);
+
+    Type *GlobalNumberType();
+    Type *GlobalAnyType();
+    Type *GlobalStringType();
+    Type *GlobalBooleanType();
+    Type *GlobalVoidType();
+    Type *GlobalNullType();
+    Type *GlobalUndefinedType();
+    Type *GlobalUnknownType();
+    Type *GlobalNeverType();
+    Type *GlobalNonPrimitiveType();
+    Type *GlobalBigintType();
+    Type *GlobalFalseType();
+    Type *GlobalTrueType();
+    Type *GlobalNumberOrBigintType();
+    Type *GlobalStringOrNumberType();
+    Type *GlobalZeroType();
+    Type *GlobalEmptyStringType();
+    Type *GlobalZeroBigintType();
+    Type *GlobalPrimitiveType();
+    Type *GlobalEmptyTupleType();
+    Type *GlobalEmptyObjectType();
+
+    NumberLiteralPool &NumberLiteralMap();
+    StringLiteralPool &StringLiteralMap();
+    StringLiteralPool &BigintLiteralMap();
+
+    TypeRelation *Relation();
+
+    RelationHolder &IdenticalResults();
+    RelationHolder &AssignableResults();
+    RelationHolder &ComparableResults();
+
+    std::unordered_set<const ir::AstNode *> &TypeStack();
+    std::unordered_map<const ir::AstNode *, Type *> &NodeCache();
+    Type *CheckTypeCached(const ir::Expression *expr);
+
+    CheckerStatus Status();
+
+    // Util
+    static bool InAssignment(const ir::AstNode *node);
+    static bool IsAssignmentOperator(lexer::TokenType op);
+    Type *GetBaseTypeOfLiteralType(Type *type);
+    static bool IsLiteralType(const Type *type);
+    static const ir::AstNode *FindAncestorGivenByType(const ir::AstNode *node, ir::AstNodeType type);
+    void CheckNonNullType(Type *type, lexer::SourcePosition lineInfo);
+    static bool MaybeTypeOfKind(const Type *type, TypeFlag flags);
+    static bool MaybeTypeOfKind(const Type *type, ObjectType::ObjectTypeKind kind);
+    static bool IsConstantMemberAccess(const ir::Expression *expr);
+    static bool IsStringLike(const ir::Expression *expr);
+    void CheckTruthinessOfType(Type *type, lexer::SourcePosition lineInfo);
+
+    // Helpers
+    static const ir::TSQualifiedName *ResolveLeftMostQualifiedName(const ir::TSQualifiedName *qualifiedName);
+    static const ir::MemberExpression *ResolveLeftMostMemberExpression(const ir::MemberExpression *expr);
+    void CheckReferenceExpression(const ir::Expression *expr, const char *invalidReferenceMsg,
+                                  const char *invalidOptionalChainMsg);
+    void CheckTestingKnownTruthyCallableOrAwaitableType(const ir::Expression *condExpr, Type *type,
+                                                        const ir::AstNode *body);
+    Type *ExtractDefinitelyFalsyTypes(Type *type);
+    Type *RemoveDefinitelyFalsyTypes(Type *type);
+    TypeFlag GetFalsyFlags(Type *type);
+    bool IsVariableUsedInConditionBody(const ir::AstNode *parent, binder::Variable *searchVar);
+    bool FindVariableInBinaryExpressionChain(const ir::AstNode *parent, binder::Variable *searchVar);
+    bool IsVariableUsedInBinaryExpressionChain(const ir::AstNode *parent, binder::Variable *searchVar);
+    Type *CreateTupleTypeFromEveryArrayExpression(const ir::Expression *expr);
+    [[noreturn]] void ThrowBinaryLikeError(lexer::TokenType op, Type *leftType, Type *rightType,
+                                           lexer::SourcePosition lineInfo);
+    [[noreturn]] void ThrowAssignmentError(Type *leftType, Type *rightType, lexer::SourcePosition lineInfo,
+                                           bool isAsSrcLeftType = false);
+
+    // Generics
+    void CheckTypeParametersNotReferenced(const ir::AstNode *parent, const ir::TSTypeParameterDeclaration *typeParams,
+                                          size_t index);
+    std::vector<binder::Variable *> CheckTypeParameters(const ir::TSTypeParameterDeclaration *typeParams);
+    Type *InstantiateGenericTypeAlias(binder::Variable *bindingVar, const ir::TSTypeParameterDeclaration *decl,
+                                      const ir::TSTypeParameterInstantiation *typeParams,
+                                      const lexer::SourcePosition &locInfo);
+    Type *InstantiateGenericInterface(binder::Variable *bindingVar, const binder::Decl *decl,
+                                      const ir::TSTypeParameterInstantiation *typeParams,
+                                      const lexer::SourcePosition &locInfo);
+    void ValidateTypeParameterInstantiation(size_t typeArgumentCount, size_t minTypeArgumentCount,
+                                            size_t numOfTypeArguments, const util::StringView &name,
+                                            const lexer::SourcePosition &locInfo);
+    bool CheckTypeParametersAreIdentical(const std::pair<std::vector<binder::Variable *>, size_t> &collectedTypeParams,
+                                         std::vector<binder::Variable *> &currentTypeParams) const;
+    std::pair<std::vector<binder::Variable *>, size_t> CollectTypeParametersFromDeclarations(
+        const ArenaVector<ir::TSInterfaceDeclaration *> &declarations);
+
+    // Type creation
+    Type *CreateNumberLiteralType(double value);
+    Type *CreateBigintLiteralType(const util::StringView &str, bool negative);
+    Type *CreateStringLiteralType(const util::StringView &str);
+    Type *CreateFunctionTypeWithSignature(Signature *callSignature);
+    Type *CreateConstructorTypeWithSignature(Signature *constructSignature);
+    Type *CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                          uint32_t minLength, uint32_t fixedLength, bool readonly);
+    Type *CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                          uint32_t minLength, uint32_t fixedLength, bool readonly, NamedTupleMemberPool &&namedMembers);
+    Type *CreateUnionType(std::vector<Type *> &&constituentTypes);
+    Type *CreateUnionType(std::initializer_list<Type *> constituentTypes);
+
+    // Object
+    ObjectLiteralPropertyInfo HandleObjectLiteralProperty(const ir::Property *prop, ObjectDescriptor *desc,
+                                                          std::vector<Type *> *stringIndexTypes, bool readonly = false);
+    void HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDescriptor *desc, lexer::SourcePosition locInfo,
+                             bool readonly = false);
+    Type *CollectStringIndexInfoTypes(const ObjectDescriptor *desc, const std::vector<Type *> &stringIndexTypes);
+    binder::Variable *ResolveNonComputedObjectProperty(const ir::MemberExpression *expr);
+    util::StringView ToPropertyName(const ir::Expression *expr, TypeFlag propNameFlags, bool computed = false,
+                                    bool *hasName = nullptr, Type **exprType = nullptr);
+    void PrefetchTypeLiteralProperties(const ir::Expression *current, ObjectDescriptor *desc);
+    void CheckTsTypeLiteralOrInterfaceMember(const ir::Expression *current, ObjectDescriptor *desc);
+    Type *CheckIndexInfoProperty(IndexInfo *info, Type *objType, lexer::SourcePosition loc);
+    Type *ResolveBasePropForObject(ObjectType *objType, util::StringView &name, Type *propNameType, bool isComputed,
+                                   bool inAssignment, lexer::SourcePosition propLoc, lexer::SourcePosition exprLoc);
+    Type *ResolveBaseProp(Type *baseType, const ir::Expression *prop, bool isComputed, lexer::SourcePosition exprLoc);
+    binder::Variable *ResolveObjectProperty(const ir::MemberExpression *expr);
+    Type *CheckTsPropertySignature(const ir::TSPropertySignature *propSignature, binder::LocalVariable *savedProp);
+    Type *CheckTsMethodSignature(const ir::TSMethodSignature *methodSignature);
+    void CheckTsIndexSignature(const ir::TSIndexSignature *indexSignature, ObjectDescriptor *desc);
+    void CheckTsSignatureDeclaration(const ir::TSSignatureDeclaration *signatureNode, ObjectDescriptor *desc);
+    void CheckTsPropertyOrMethodSignature(const ir::Expression *current, ObjectDescriptor *desc);
+    void HandleNumberIndexInfo(ObjectDescriptor *desc, Type *indexType, bool readonly = false);
+    util::StringView HandleComputedPropertyName(const ir::Expression *propKey, ObjectDescriptor *desc, Type *propType,
+                                                std::vector<Type *> *stringIndexTypes, bool *handleNextProp,
+                                                lexer::SourcePosition locInfo, bool readonly = false);
+    void CheckIndexConstraints(Type *type) const;
+
+    // Function
+    Signature *HandleFunctionReturn(const ir::ScriptFunction *func, SignatureInfo *signatureInfo,
+                                    binder::Variable *funcVar = nullptr);
+    Type *CreateTypeForPatternParameter(const ir::Expression *patternNode, const ir::Expression *initNode);
+    void CreateTypeForObjectPatternParameter(ObjectType *patternType, const ir::Expression *patternNode,
+                                             const ir::Expression *initNode);
+    void CheckFunctionParameterDeclaration(const ArenaVector<ir::Expression *> &params, SignatureInfo *signatureInfo);
+    void InferFunctionDeclarationType(const binder::FunctionDecl *decl, binder::Variable *funcVar);
+    void CollectTypesFromReturnStatements(const ir::AstNode *parent, std::vector<Type *> &returnTypes);
+    void CheckAllCodePathsInNonVoidFunctionReturnOrThrow(const ir::ScriptFunction *func, lexer::SourcePosition lineInfo,
+                                                         const char *errMsg);
+    FunctionParameterInfo GetFunctionParameterInfo(ir::Expression *expr);
+    Type *GetParamTypeFromParamInfo(const FunctionParameterInfo &paramInfo, Type *annotationType, Type *patternType);
+
+    // Destructuring
+    void HandleVariableDeclarationWithContext(const ir::Expression *id, Type *inferedType,
+                                              VariableBindingContext context, DestructuringType destructuringType,
+                                              bool annotationTypeUsed, bool inAssignment = false);
+    void HandleIdentifierDeclarationWithContext(const ir::Identifier *identNode, Type *inferedType,
+                                                DestructuringType destructuringType, bool annotationTypeUsed,
+                                                bool inAssignment);
+    void HandlePropertyDeclarationWithContext(const ir::Property *prop, Type *inferedType,
+                                              VariableBindingContext context, DestructuringType destructuringType,
+                                              bool annotationTypeUsed, bool inAssignment);
+    void HandleAssignmentPatternWithContext(const ir::AssignmentExpression *assignmentPattern, Type *inferedType,
+                                            VariableBindingContext context, DestructuringType destructuringType,
+                                            bool annotationTypeUsed, bool inAssignment);
+    void HandleArrayPatternWithContext(const ir::ArrayExpression *arrayPattern, Type *inferedType,
+                                       VariableBindingContext context, bool annotationTypeUsed, bool inAssignment);
+    void HandleRestElementWithContext(const ir::SpreadElement *restElement, Type *inferedType,
+                                      VariableBindingContext context, DestructuringType destructuringType,
+                                      bool annotationTypeUsed, bool inAssignment);
+    void ValidateTypeAnnotationAndInitType(const ir::Expression *initNode, Type **initType, const Type *annotationType,
+                                           Type *patternType, lexer::SourcePosition locInfo);
+    Type *GetVariableType(const util::StringView &name, Type *inferedType, Type *initType, binder::Variable *resultVar,
+                          DestructuringType destructuringType, const lexer::SourcePosition &locInfo,
+                          bool annotationTypeUsed, bool inAssignment = false);
+    Type *GetVariableTypeInObjectDestructuring(const util::StringView &name, Type *inferedType, Type *initType,
+                                               bool annotationTypeUsed, const lexer::SourcePosition &locInfo,
+                                               bool inAssignment = false);
+    Type *GetVariableTypeInObjectDestructuringWithTargetUnion(const util::StringView &name, UnionType *inferedType,
+                                                              Type *initType, bool annotationTypeUsed,
+                                                              const lexer::SourcePosition &locInfo,
+                                                              bool inAssignment = false);
+    Type *GetVariableTypeInArrayDestructuring(Type *inferedType, Type *initType, const lexer::SourcePosition &locInfo,
+                                              bool inAssignment);
+    Type *GetVariableTypeInArrayDestructuringWithTargetUnion(UnionType *inferedType, Type *initType,
+                                                             const lexer::SourcePosition &locInfo, bool inAssignment);
+    Type *GetRestElementType(Type *inferedType, binder::Variable *resultVar, DestructuringType destructuringType,
+                             const lexer::SourcePosition &locInfo, bool inAssignment = false);
+    Type *GetRestElementTypeInArrayDestructuring(Type *inferedType, const lexer::SourcePosition &locInfo);
+    Type *GetRestElementTypeInObjectDestructuring(Type *inferedType, const lexer::SourcePosition &locInfo);
+    Type *GetNextInferedTypeForArrayPattern(Type *inferedType);
+    Type *CreateTupleTypeForRest(TupleTypeIterator *iterator);
+    Type *CreateArrayTypeForRest(UnionType *inferedType);
+    Type *CreateObjectTypeForRest(ObjectType *objType);
+    Type *CreateInitializerTypeForPattern(const Type *patternType, const ir::Expression *initNode,
+                                          bool validateCurrent = true);
+    Type *CreateInitializerTypeForObjectPattern(const ObjectType *patternType, const ir::ObjectExpression *initNode,
+                                                bool validateCurrent);
+    Type *CreateInitializerTypeForArrayPattern(const TupleType *patternType, const ir::ArrayExpression *initNode,
+                                               bool validateCurrent);
+    static bool ShouldCreatePropertyValueName(const ir::Expression *propValue);
+    void CreatePatternName(const ir::AstNode *node, std::stringstream &ss) const;
+
+    // Type elaboration
+    bool ElaborateElementwise(TypeOrNode source, const Type *targetType, lexer::SourcePosition locInfo);
+    bool ElaborateObjectLiteral(TypeOrNode source, const Type *targetType, lexer::SourcePosition locInfo);
+    bool ElaborateObjectLiteralWithNode(const ir::ObjectExpression *sourceNode, const Type *targetType,
+                                        ObjectLiteralElaborationData *elaborationData);
+    void ElaborateObjectLiteralWithType(const ObjectLiteralType *sourceType, const Type *targetType,
+                                        const std::unordered_map<uint32_t, ObjectType *> &potentialObjectTypes,
+                                        lexer::SourcePosition locInfo);
+    bool ElaborateArrayLiteral(TypeOrNode source, const Type *targetType, lexer::SourcePosition locInfo);
+    void ElaborateArrayLiteralWithNode(const ir::ArrayExpression *sourceNode, const Type *targetType,
+                                       std::unordered_map<uint32_t, Type *> *potentialTypes,
+                                       lexer::SourcePosition locInfo);
+    void ElaborateArrayLiteralWithType(const TupleType *sourceType, const Type *targetType,
+                                       const std::unordered_map<uint32_t, Type *> &potentialTypes);
+    void GetPotentialTypesAndIndexInfosForElaboration(const Type *targetType,
+                                                      ObjectLiteralElaborationData *elaborationData);
+    static IndexInfoTypePair GetIndexInfoTypePair(const ObjectType *type);
+    void CheckTargetTupleLengthConstraints(const Type *targetType, const ir::ArrayExpression *sourceNode,
+                                           std::unordered_map<uint32_t, Type *> *potentialTypes,
+                                           const lexer::SourcePosition &locInfo);
+    std::vector<Type *> CollectTargetTypesForArrayElaborationWithNodeFromTargetUnion(
+        std::unordered_map<uint32_t, Type *> *potentialTypes, const ir::Expression *currentSourceElement,
+        uint32_t tupleIdx);
+    static std::vector<Type *> CollectTargetTypesForArrayElaborationWithTypeFromTargetUnion(
+        const std::unordered_map<uint32_t, Type *> &potentialTypes, uint32_t tupleIdx);
+    static bool CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targetType,
+                                                                 ObjectLiteralElaborationData *elaborationData);
+    Type *GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type *targetType,
+                                                                ObjectLiteralElaborationData *elaborationData,
+                                                                const util::StringView &propName,
+                                                                const ir::Expression *propValue);
+    Type *GetTargetPropertyTypeFromTargetForElaborationWithType(
+        const Type *targetType, const std::unordered_map<uint32_t, ObjectType *> &potentialObjectTypes,
+        const util::StringView &propName);
+    Type *GetindexInfoTypeOrThrowError(const Type *targetType, ObjectLiteralElaborationData *elaborationData,
+                                       const util::StringView &propName, bool computed, bool numberLiteralName,
+                                       lexer::SourcePosition locInfo);
+    Type *GetUnaryResultType(Type *operandType);
+    Type *InferVariableDeclarationType(const ir::Identifier *decl);
+
+    // Type relation
+    bool IsTypeIdenticalTo(const Type *source, const Type *target) const;
+    bool IsTypeIdenticalTo(const Type *source, const Type *target, const std::string &errMsg,
+                           const lexer::SourcePosition &errPos) const;
+    bool IsTypeIdenticalTo(const Type *source, const Type *target, std::initializer_list<TypeErrorMessageElement> list,
+                           const lexer::SourcePosition &errPos) const;
+    bool IsTypeAssignableTo(const Type *source, const Type *target) const;
+    bool IsTypeAssignableTo(const Type *source, const Type *target, const std::string &errMsg,
+                            const lexer::SourcePosition &errPos) const;
+    bool IsTypeAssignableTo(const Type *source, const Type *target, std::initializer_list<TypeErrorMessageElement> list,
+                            const lexer::SourcePosition &errPos) const;
+    bool IsTypeComparableTo(const Type *source, const Type *target) const;
+    bool IsTypeComparableTo(const Type *source, const Type *target, const std::string &errMsg,
+                            const lexer::SourcePosition &errPos) const;
+    bool IsTypeComparableTo(const Type *source, const Type *target, std::initializer_list<TypeErrorMessageElement> list,
+                            const lexer::SourcePosition &errPos) const;
+    bool AreTypesComparable(const Type *source, const Type *target) const;
+    bool IsTypeEqualityComparableTo(const Type *source, const Type *target) const;
+    bool IsAllTypesAssignableTo(Type *source, Type *target);
+
+    // Binary like expression
+    Type *CheckBinaryOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                              const ir::Expression *rightExpr, const ir::AstNode *expr, lexer::TokenType op);
+    Type *CheckPlusOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                            const ir::Expression *rightExpr, const ir::AstNode *expr, lexer::TokenType op);
+    Type *CheckCompareOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                               const ir::Expression *rightExpr, const ir::AstNode *expr, lexer::TokenType op);
+    Type *CheckAndOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr);
+    Type *CheckOrOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr);
+    Type *CheckInstanceofExpression(Type *leftType, Type *rightType, const ir::Expression *rightExpr,
+                                    const ir::AstNode *expr);
+    Type *CheckInExpression(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                            const ir::Expression *rightExpr, const ir::AstNode *expr);
+    void CheckAssignmentOperator(lexer::TokenType op, const ir::Expression *leftExpr, Type *leftType, Type *valueType);
+
+    friend class ScopeContext;
+
+private:
+    ArenaAllocator *allocator_;
+    binder::Binder *binder_;
+    const ir::BlockStatement *rootNode_;
+    binder::Scope *scope_;
+    GlobalTypesHolder *globalTypes_;
+
+    NumberLiteralPool numberLiteralMap_;
+    StringLiteralPool stringLiteralMap_;
+    StringLiteralPool bigintLiteralMap_;
+
+    TypeRelation *relation_;
+
+    RelationHolder identicalResults_;
+    RelationHolder assignableResults_;
+    RelationHolder comparableResults_;
+
+    std::unordered_set<const ir::AstNode *> typeStack_;
+    std::unordered_map<const ir::AstNode *, Type *> nodeCache_;
+    std::vector<binder::Scope *> scopeStack_;
+
+    CheckerStatus status_;
+};
+
+class ScopeContext {
+public:
+    explicit ScopeContext(Checker *checker, binder::Scope *newScope) : checker_(checker), prevScope_(checker_->scope_)
+    {
+        checker_->scope_ = newScope;
+    }
+
+    ~ScopeContext()
+    {
+        checker_->scope_ = prevScope_;
+    }
+
+    NO_COPY_SEMANTIC(ScopeContext);
+    NO_MOVE_SEMANTIC(ScopeContext);
+
+private:
+    Checker *checker_;
+    binder::Scope *prevScope_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* CHECKER_H */
diff --git a/es2panda/typescript/core/binaryLikeExpression.cpp b/es2panda/typescript/core/binaryLikeExpression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e8254afd59d630e35c31c2267e776d1941d1a12
--- /dev/null
+++ b/es2panda/typescript/core/binaryLikeExpression.cpp
@@ -0,0 +1,232 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/memberExpression.h>
+
+#include <typescript/checker.h>
+
+namespace panda::es2panda::checker {
+
+Type *Checker::CheckBinaryOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                                   const ir::Expression *rightExpr, const ir::AstNode *expr, lexer::TokenType op)
+{
+    CheckNonNullType(leftType, leftExpr->Start());
+    CheckNonNullType(rightType, rightExpr->Start());
+
+    if (leftType->HasTypeFlag(TypeFlag::BOOLEAN_LIKE) && rightType->HasTypeFlag(TypeFlag::BOOLEAN_LIKE)) {
+        lexer::TokenType suggestedOp;
+        switch (op) {
+            case lexer::TokenType::PUNCTUATOR_BITWISE_OR:
+            case lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL: {
+                suggestedOp = lexer::TokenType::PUNCTUATOR_LOGICAL_OR;
+                break;
+            }
+            case lexer::TokenType::PUNCTUATOR_BITWISE_AND:
+            case lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL: {
+                suggestedOp = lexer::TokenType::PUNCTUATOR_LOGICAL_AND;
+                break;
+            }
+            case lexer::TokenType::PUNCTUATOR_BITWISE_XOR:
+            case lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL: {
+                suggestedOp = lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL;
+                break;
+            }
+            default: {
+                suggestedOp = lexer::TokenType::EOS;
+                break;
+            }
+        }
+
+        if (suggestedOp != lexer::TokenType::EOS) {
+            ThrowTypeError(
+                {"The ", op, " operator is not allowed for boolean types. Consider using ", suggestedOp, " instead"},
+                expr->Start());
+        }
+    }
+
+    if (!leftType->HasTypeFlag(TypeFlag::VALID_ARITHMETIC_TYPE)) {
+        ThrowTypeError(
+            "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an "
+            "enum "
+            "type.",
+            expr->Start());
+    }
+
+    if (!rightType->HasTypeFlag(TypeFlag::VALID_ARITHMETIC_TYPE)) {
+        ThrowTypeError(
+            "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an "
+            "enum "
+            "type.",
+            rightExpr->Start());
+    }
+
+    Type *resultType = nullptr;
+    if ((leftType->IsAnyType() && rightType->IsAnyType()) ||
+        !(leftType->HasTypeFlag(TypeFlag::BIGINT_LIKE) || rightType->HasTypeFlag(TypeFlag::BIGINT_LIKE))) {
+        resultType = GlobalNumberType();
+    } else if (leftType->HasTypeFlag(TypeFlag::BIGINT_LIKE) && rightType->HasTypeFlag(TypeFlag::BIGINT_LIKE)) {
+        if (op == lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT ||
+            op == lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL) {
+            ThrowTypeError({"operator ", op, " cannot be applied to types 'bigint' and 'bigint'"}, expr->Start());
+        }
+        resultType = GlobalBigintType();
+    } else {
+        ThrowBinaryLikeError(op, leftType, rightType, expr->Start());
+    }
+
+    CheckAssignmentOperator(op, leftExpr, leftType, resultType);
+    return resultType;
+}
+
+Type *Checker::CheckPlusOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                                 const ir::Expression *rightExpr, const ir::AstNode *expr, lexer::TokenType op)
+{
+    if (!leftType->HasTypeFlag(TypeFlag::STRING_LIKE) && !rightType->HasTypeFlag(TypeFlag::STRING_LIKE)) {
+        CheckNonNullType(leftType, leftExpr->Start());
+        CheckNonNullType(rightType, rightExpr->Start());
+    }
+
+    Type *resultType = nullptr;
+    if (IsTypeAssignableTo(leftType, GlobalNumberType()) && IsTypeAssignableTo(rightType, GlobalNumberType())) {
+        resultType = GlobalNumberType();
+    } else if (IsTypeAssignableTo(leftType, GlobalBigintType()) && IsTypeAssignableTo(rightType, GlobalBigintType())) {
+        resultType = GlobalBigintType();
+    } else if (IsTypeAssignableTo(leftType, GlobalStringType()) || IsTypeAssignableTo(rightType, GlobalStringType())) {
+        resultType = GlobalStringType();
+    } else if (MaybeTypeOfKind(leftType, TypeFlag::UNKNOWN)) {
+        ThrowTypeError("object is of type 'unknown'", leftExpr->Start());
+    } else if (MaybeTypeOfKind(rightType, TypeFlag::UNKNOWN)) {
+        ThrowTypeError("object is of type 'unknown'", rightExpr->Start());
+    } else if (leftType->IsAnyType() || rightType->IsAnyType()) {
+        resultType = GlobalAnyType();
+    } else {
+        ThrowBinaryLikeError(op, leftType, rightType, expr->Start());
+    }
+
+    if (op == lexer::TokenType::PUNCTUATOR_PLUS_EQUAL) {
+        CheckAssignmentOperator(op, leftExpr, leftType, resultType);
+    }
+
+    return resultType;
+}
+
+Type *Checker::CheckCompareOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                                    const ir::Expression *rightExpr, const ir::AstNode *expr, lexer::TokenType op)
+{
+    CheckNonNullType(leftType, leftExpr->Start());
+    CheckNonNullType(rightType, rightExpr->Start());
+
+    leftType = GetBaseTypeOfLiteralType(leftType);
+    rightType = GetBaseTypeOfLiteralType(rightType);
+    if (AreTypesComparable(leftType, rightType) || (IsTypeAssignableTo(leftType, GlobalNumberOrBigintType()) &&
+                                                    IsTypeAssignableTo(rightType, GlobalNumberOrBigintType()))) {
+        return GlobalBooleanType();
+    }
+
+    ThrowBinaryLikeError(op, leftType, rightType, expr->Start());
+
+    return GlobalAnyType();
+}
+
+Type *Checker::CheckAndOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr)
+{
+    CheckTruthinessOfType(leftType, leftExpr->Start());
+
+    if (static_cast<uint64_t>(leftType->GetTypeFacts()) & static_cast<uint64_t>(TypeFacts::TRUTHY)) {
+        Type *resultType =
+            CreateUnionType({ExtractDefinitelyFalsyTypes(GetBaseTypeOfLiteralType(rightType)), rightType});
+        return resultType;
+    }
+
+    return leftType;
+}
+
+Type *Checker::CheckOrOperator(Type *leftType, Type *rightType, const ir::Expression *leftExpr)
+{
+    CheckTruthinessOfType(leftType, leftExpr->Start());
+
+    if (static_cast<uint64_t>(leftType->GetTypeFacts()) & static_cast<uint64_t>(TypeFacts::FALSY)) {
+        // TODO(aszilagyi): subtype reduction in the result union
+        Type *resultType = CreateUnionType({RemoveDefinitelyFalsyTypes(leftType), rightType});
+        return resultType;
+    }
+
+    return leftType;
+}
+
+static bool TypeHasCallOrConstructSignatures(Type *type)
+{
+    return type->IsObjectType() &&
+           (!type->AsObjectType()->CallSignatures().empty() || !type->AsObjectType()->ConstructSignatures().empty());
+}
+
+Type *Checker::CheckInstanceofExpression(Type *leftType, Type *rightType, const ir::Expression *rightExpr,
+                                         const ir::AstNode *expr)
+{
+    if (leftType->TypeFlags() != TypeFlag::ANY && IsAllTypesAssignableTo(leftType, GlobalPrimitiveType())) {
+        ThrowTypeError({"The left-hand side of an 'instanceof' expression must be of type 'any',",
+                        " an object type or a type parameter."},
+                       expr->Start());
+    }
+
+    // TODO(aszilagyi): Check if right type is subtype of globalFunctionType
+    if (rightType->TypeFlags() != TypeFlag::ANY && !TypeHasCallOrConstructSignatures(rightType)) {
+        ThrowTypeError({"The right-hand side of an 'instanceof' expression must be of type 'any'",
+                        " or of a type assignable to the 'Function' interface type."},
+                       rightExpr->Start());
+    }
+
+    return GlobalBooleanType();
+}
+
+Type *Checker::CheckInExpression(Type *leftType, Type *rightType, const ir::Expression *leftExpr,
+                                 const ir::Expression *rightExpr, const ir::AstNode *expr)
+{
+    CheckNonNullType(leftType, leftExpr->Start());
+    CheckNonNullType(rightType, rightExpr->Start());
+
+    // TODO(aszilagyi): Check IsAllTypesAssignableTo with ESSymbol too
+    if (leftType->TypeFlags() != TypeFlag::ANY && !IsAllTypesAssignableTo(leftType, GlobalStringOrNumberType())) {
+        ThrowTypeError(
+            {"The left-hand side of an 'in' expression must be of type 'any',", " 'string', 'number', or 'symbol'."},
+            expr->Start());
+    }
+
+    // TODO(aszilagyi): Handle type parameters
+    if (!IsAllTypesAssignableTo(rightType, GlobalNonPrimitiveType())) {
+        ThrowTypeError("The right-hand side of an 'in' expression must not be a primitive.", rightExpr->Start());
+    }
+
+    return GlobalBooleanType();
+}
+
+void Checker::CheckAssignmentOperator(lexer::TokenType op, const ir::Expression *leftExpr, Type *leftType,
+                                      Type *valueType)
+{
+    if (IsAssignmentOperator(op)) {
+        CheckReferenceExpression(
+            leftExpr, "the left hand side of an assigment expression must be a variable or a property access",
+            "The left-hand side of an assignment expression may not be an optional property access.");
+
+        if (!IsTypeAssignableTo(valueType, leftType)) {
+            ThrowAssignmentError(valueType, leftType, leftExpr->Start(),
+                                 leftExpr->Parent()->AsAssignmentExpression()->Right()->IsMemberExpression() ||
+                                     leftExpr->Parent()->AsAssignmentExpression()->Right()->IsChainExpression());
+        }
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/destructuring.cpp b/es2panda/typescript/core/destructuring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0e875a46cce57aa32c46f4b545c4a60935fdd6e0
--- /dev/null
+++ b/es2panda/typescript/core/destructuring.cpp
@@ -0,0 +1,917 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/expressions/literals/bigIntLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/base/property.h>
+#include <ir/base/spreadElement.h>
+#include <util/helpers.h>
+#include <binder/variable.h>
+#include <binder/scope.h>
+#include <binder/declaration.h>
+
+#include <typescript/checker.h>
+
+namespace panda::es2panda::checker {
+
+void Checker::HandleVariableDeclarationWithContext(const ir::Expression *id, Type *inferedType,
+                                                   VariableBindingContext context, DestructuringType destructuringType,
+                                                   bool annotationTypeUsed, bool inAssignment)
+{
+    if (id->IsIdentifier()) {
+        HandleIdentifierDeclarationWithContext(id->AsIdentifier(), inferedType, destructuringType, annotationTypeUsed,
+                                               inAssignment);
+        return;
+    }
+
+    if (id->IsProperty()) {
+        HandlePropertyDeclarationWithContext(id->AsProperty(), inferedType, context, destructuringType,
+                                             annotationTypeUsed, inAssignment);
+        return;
+    }
+
+    if (id->IsAssignmentPattern()) {
+        HandleAssignmentPatternWithContext(id->AsAssignmentPattern(), inferedType, context, destructuringType,
+                                           annotationTypeUsed, inAssignment);
+        return;
+    }
+
+    if (id->IsArrayPattern()) {
+        if (!inferedType->IsArrayType() &&
+            !(inferedType->IsObjectType() && inferedType->AsObjectType()->IsTupleType()) &&
+            !inferedType->IsUnionType()) {
+            ThrowTypeError(
+                {"Type '", inferedType, "' must have a '[Symbol.Iterator]()' method that returns an interator"},
+                id->Start());
+        }
+
+        HandleArrayPatternWithContext(id->AsArrayPattern(), inferedType, context, annotationTypeUsed, inAssignment);
+        return;
+    }
+
+    if (id->IsObjectPattern()) {
+        for (auto *it : id->AsObjectPattern()->Properties()) {
+            HandleVariableDeclarationWithContext(it, inferedType, context, DestructuringType::OBJECT_DESTRUCTURING,
+                                                 annotationTypeUsed, inAssignment);
+        }
+
+        return;
+    }
+
+    if (id->IsRestElement()) {
+        HandleRestElementWithContext(id->AsRestElement(), inferedType, context, destructuringType, annotationTypeUsed,
+                                     inAssignment);
+        return;
+    }
+
+    ASSERT(id->IsOmittedExpression());
+    if (inferedType->IsObjectType() && inferedType->AsObjectType()->IsTupleType()) {
+        inferedType->AsObjectType()->AsTupleType()->Iterator()->Next();
+    }
+}
+
+void Checker::HandleIdentifierDeclarationWithContext(const ir::Identifier *identNode, Type *inferedType,
+                                                     DestructuringType destructuringType, bool annotationTypeUsed,
+                                                     bool inAssignment)
+{
+    const util::StringView &identName = identNode->Name();
+    binder::ScopeFindResult result = scope_->Find(identName);
+
+    if (inAssignment) {
+        if (!result.variable) {
+            ThrowTypeError({"Cannot find name '", identName, "'."}, identNode->Start());
+        }
+
+        Type *varType = GetVariableType(identName, inferedType, nullptr, nullptr, destructuringType, identNode->Start(),
+                                        annotationTypeUsed, true);
+
+        if (!IsTypeAssignableTo(varType, result.variable->TsType())) {
+            ThrowAssignmentError(varType, result.variable->TsType(), identNode->Start());
+        }
+
+        return;
+    }
+
+    ASSERT(result.variable);
+
+    Type *varType = GetVariableType(identNode->Name(), inferedType, nullptr, result.variable, destructuringType,
+                                    identNode->Start(), annotationTypeUsed);
+
+    varType->SetVariable(result.variable);
+    result.variable->SetTsType(varType);
+}
+
+void Checker::HandlePropertyDeclarationWithContext(const ir::Property *prop, Type *inferedType,
+                                                   VariableBindingContext context, DestructuringType destructuringType,
+                                                   bool annotationTypeUsed, bool inAssignment)
+{
+    if (prop->IsComputed()) {
+        // TODO(aszilagyi)
+        return;
+    }
+
+    util::StringView propName;
+    util::StringView searchVarName;
+    lexer::SourcePosition errorLoc {};
+    bool fetchVar = true;
+    Type *initType = nullptr;
+
+    if (prop->Value()) {
+        if (prop->Value()->IsIdentifier()) {
+            searchVarName = prop->Value()->AsIdentifier()->Name();
+            errorLoc = prop->Value()->Start();
+        } else if (prop->Value()->IsAssignmentPattern()) {
+            const ir::AssignmentExpression *assignmentPattern = prop->Value()->AsAssignmentPattern();
+
+            initType = GetBaseTypeOfLiteralType(assignmentPattern->Right()->Check(this));
+
+            if (assignmentPattern->Left()->IsIdentifier()) {
+                searchVarName = assignmentPattern->Left()->AsIdentifier()->Name();
+            } else {
+                fetchVar = false;
+            }
+        } else {
+            fetchVar = false;
+        }
+
+        if (initType && !prop->Value()->AsAssignmentPattern()->Left()->IsIdentifier() && inAssignment) {
+            HandleVariableDeclarationWithContext(prop->Value()->AsAssignmentPattern()->Left(), initType, context,
+                                                 destructuringType, annotationTypeUsed, inAssignment);
+        }
+
+        errorLoc = prop->Key()->Start();
+
+        propName = ToPropertyName(prop->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME);
+    } else {
+        ASSERT(prop->Key()->IsIdentifier());
+        propName = prop->Value()->AsIdentifier()->Name();
+        searchVarName = propName;
+        errorLoc = prop->Key()->Start();
+    }
+
+    binder::Variable *resultVar = nullptr;
+
+    if (fetchVar) {
+        binder::ScopeFindResult result = scope_->Find(searchVarName);
+        resultVar = result.variable;
+    }
+    if (fetchVar && inAssignment && !resultVar) {
+        ThrowTypeError({"No value exists in scope for the shorthand property '", searchVarName,
+                        "'. Either declare one or provide an initializer."},
+                       prop->Start());
+    }
+    if (fetchVar && inAssignment && initType && !IsTypeAssignableTo(initType, resultVar->TsType())) {
+        ThrowAssignmentError(initType, resultVar->TsType(), prop->Start());
+    }
+
+    Type *varType = GetVariableType(propName, inferedType, initType, resultVar, destructuringType, errorLoc,
+                                    annotationTypeUsed, inAssignment);
+
+    if (inAssignment && fetchVar && !IsTypeAssignableTo(varType, resultVar->TsType())) {
+        ThrowAssignmentError(varType, resultVar->TsType(), prop->Start());
+    }
+    if (fetchVar) {
+        varType->SetVariable(resultVar);
+        resultVar->SetTsType(varType);
+        return;
+    }
+
+    HandleVariableDeclarationWithContext(initType ? prop->Value()->AsAssignmentPattern()->Left() : prop->Value(),
+                                         varType, context, destructuringType, annotationTypeUsed, inAssignment);
+}
+
+void Checker::HandleAssignmentPatternWithContext(const ir::AssignmentExpression *assignmentPattern, Type *inferedType,
+                                                 VariableBindingContext context, DestructuringType destructuringType,
+                                                 bool annotationTypeUsed, bool inAssignment)
+{
+    Type *initType = CheckTypeCached(assignmentPattern->Right());
+
+    if (assignmentPattern->Left()->IsIdentifier()) {
+        const ir::Identifier *identNode = assignmentPattern->Left()->AsIdentifier();
+        binder::ScopeFindResult result = scope_->Find(identNode->Name());
+
+        if (inAssignment) {
+            if (!result.variable) {
+                ThrowTypeError({"Cannot find name '", identNode->Name(), "'."}, identNode->Start());
+            }
+
+            if (!IsTypeAssignableTo(initType, result.variable->TsType())) {
+                ThrowAssignmentError(initType, result.variable->TsType(), identNode->Start());
+            }
+
+            Type *varType = GetVariableType(identNode->Name(), inferedType, GetBaseTypeOfLiteralType(initType), nullptr,
+                                            destructuringType, identNode->Start(), annotationTypeUsed, true);
+
+            if (!IsTypeAssignableTo(varType, result.variable->TsType())) {
+                ThrowAssignmentError(varType, result.variable->TsType(), identNode->Start());
+            }
+
+            return;
+        }
+
+        ASSERT(result.variable);
+
+        Type *varType = GetVariableType(identNode->Name(), inferedType, GetBaseTypeOfLiteralType(initType),
+                                        result.variable, destructuringType, identNode->Start(), annotationTypeUsed);
+
+        varType->SetVariable(result.variable);
+        result.variable->SetTsType(varType);
+
+        return;
+    }
+
+    if (inferedType->IsUnionType()) {
+        inferedType->AsUnionType()->AddConstituentType(initType, relation_);
+    } else {
+        inferedType = CreateUnionType({initType, inferedType});
+    }
+
+    HandleVariableDeclarationWithContext(assignmentPattern->Left(), inferedType, context, destructuringType,
+                                         annotationTypeUsed, inAssignment);
+}
+
+void Checker::HandleArrayPatternWithContext(const ir::ArrayExpression *arrayPattern, Type *inferedType,
+                                            VariableBindingContext context, bool annotationTypeUsed, bool inAssignment)
+{
+    for (auto *it : arrayPattern->Elements()) {
+        Type *nextInferedType = inferedType;
+
+        if (it->IsArrayPattern() || it->IsObjectPattern() ||
+            (it->IsAssignmentPattern() && (it->AsAssignmentPattern()->Left()->IsArrayPattern() ||
+                                           it->AsAssignmentPattern()->Left()->IsObjectPattern()))) {
+            nextInferedType = GetNextInferedTypeForArrayPattern(inferedType);
+            if (!nextInferedType) {
+                ThrowTypeError(
+                    {"Type '", inferedType, "' must have a '[Symbol.Iterator]()' method that returns an interator"},
+                    it->Start());
+            }
+        }
+
+        HandleVariableDeclarationWithContext(it, nextInferedType, context, DestructuringType::ARRAY_DESTRUCTURING,
+                                             annotationTypeUsed, inAssignment);
+    }
+}
+
+Type *Checker::GetNextInferedTypeForArrayPattern(Type *inferedType)
+{
+    if (inferedType->IsArrayType()) {
+        return inferedType->AsArrayType()->ElementType();
+    }
+
+    if (inferedType->IsObjectType() && inferedType->AsObjectType()->IsTupleType()) {
+        return inferedType->AsObjectType()->AsTupleType()->Iterator()->Next();
+    }
+
+    if (inferedType->IsUnionType()) {
+        std::vector<Type *> unionTypes;
+
+        for (auto *type : inferedType->AsUnionType()->ConstituentTypes()) {
+            if (type->IsArrayType()) {
+                unionTypes.push_back(type->AsArrayType()->ElementType());
+            } else if (type->IsObjectType() && type->AsObjectType()->IsTupleType()) {
+                TupleType *tupleType = type->AsObjectType()->AsTupleType();
+                Type *iter = tupleType->Iterator()->Next();
+
+                if (!iter) {
+                    continue;
+                }
+
+                unionTypes.push_back(iter);
+            } else {
+                return nullptr;
+            }
+        }
+
+        return CreateUnionType(std::move(unionTypes));
+    }
+
+    return nullptr;
+}
+
+void Checker::HandleRestElementWithContext(const ir::SpreadElement *restElement, Type *inferedType,
+                                           VariableBindingContext context, DestructuringType destructuringType,
+                                           bool annotationTypeUsed, bool inAssignment)
+{
+    binder::Variable *restVar = nullptr;
+
+    if (restElement->Argument()->IsIdentifier()) {
+        binder::ScopeFindResult result = scope_->Find(restElement->Argument()->AsIdentifier()->Name());
+        if (inAssignment && !result.variable) {
+            ThrowTypeError({"Cannot find name '", restElement->Argument()->AsIdentifier()->Name(), "'."},
+                           restElement->Argument()->Start());
+        }
+
+        ASSERT(result.variable);
+        restVar = result.variable;
+    }
+
+    Type *restType =
+        GetRestElementType(inferedType, restVar, destructuringType, restElement->Argument()->Start(), inAssignment);
+
+    if (restVar && !inAssignment) {
+        restType->SetVariable(restVar);
+        restVar->SetTsType(restType);
+        return;
+    }
+
+    if (restVar && inAssignment) {
+        IsTypeAssignableTo(restType, restVar->TsType(),
+                           {"Type '", restType, "' is not assignable to type '", restVar->TsType(), "'."},
+                           restElement->Argument()->Start());
+        return;
+    }
+
+    ASSERT(destructuringType == DestructuringType::ARRAY_DESTRUCTURING);
+    HandleVariableDeclarationWithContext(restElement->Argument(), restType, context, destructuringType,
+                                         annotationTypeUsed, inAssignment);
+}
+
+void Checker::ValidateTypeAnnotationAndInitType(const ir::Expression *initNode, Type **initType,
+                                                const Type *annotationType, Type *patternType,
+                                                lexer::SourcePosition locInfo)
+{
+    TypeOrNode elaborateSource;
+
+    if (initNode && annotationType) {
+        elaborateSource = initNode;
+        if (!ElaborateElementwise(elaborateSource, annotationType, locInfo)) {
+            IsTypeAssignableTo(*initType, annotationType,
+                               {"Type '", AsSrc(*initType), "' is not assignable to type '", annotationType, "'"},
+                               locInfo);
+        }
+    }
+
+    if (patternType) {
+        if (annotationType) {
+            elaborateSource = patternType;
+            ElaborateElementwise(elaborateSource, annotationType, locInfo);
+            return;
+        }
+
+        ASSERT(initNode);
+        *initType = CreateInitializerTypeForPattern(patternType, initNode);
+    }
+}
+
+Type *Checker::GetVariableType(const util::StringView &name, Type *inferedType, Type *initType,
+                               binder::Variable *resultVar, DestructuringType destructuringType,
+                               const lexer::SourcePosition &locInfo, bool annotationTypeUsed, bool inAssignment)
+{
+    Type *varType = nullptr;
+
+    if (destructuringType == DestructuringType::NO_DESTRUCTURING) {
+        varType = inferedType ? inferedType : GlobalAnyType();
+    } else if (destructuringType == DestructuringType::OBJECT_DESTRUCTURING) {
+        varType = GetVariableTypeInObjectDestructuring(name, inferedType, initType, annotationTypeUsed, locInfo,
+                                                       inAssignment);
+    } else if (destructuringType == DestructuringType::ARRAY_DESTRUCTURING) {
+        varType = GetVariableTypeInArrayDestructuring(inferedType, initType, locInfo, inAssignment);
+    }
+
+    if (resultVar) {
+        Type *resolvedType = resultVar->TsType();
+
+        if (resolvedType && !inAssignment) {
+            IsTypeIdenticalTo(resolvedType, varType,
+                              {"Subsequent variable declaration must have the same type. Variable '", resultVar->Name(),
+                               "' must be of type '", resolvedType, "', but here has type '", varType, "'."},
+                              locInfo);
+        }
+    }
+
+    return varType ? varType : GlobalAnyType();
+}
+
+Type *Checker::GetVariableTypeInObjectDestructuring(const util::StringView &name, Type *inferedType, Type *initType,
+                                                    bool annotationTypeUsed, const lexer::SourcePosition &locInfo,
+                                                    bool inAssignment)
+{
+    if (inferedType->IsUnionType()) {
+        return GetVariableTypeInObjectDestructuringWithTargetUnion(name, inferedType->AsUnionType(), initType,
+                                                                   annotationTypeUsed, locInfo, inAssignment);
+    }
+
+    if (inferedType->IsObjectType()) {
+        binder::LocalVariable *property = inferedType->AsObjectType()->GetProperty(name);
+
+        if (!property && !initType) {
+            if (inferedType->AsObjectType()->IsObjectLiteralType()) {
+                ThrowTypeError(
+                    "Initializer provides no value for this binding element and the binding element has no default "
+                    "value",
+                    locInfo);
+            }
+
+            ThrowTypeError({"Property '", name, "' does not exist on type '", inferedType}, locInfo);
+        }
+
+        if (property) {
+            property->AddFlag(binder::VariableFlags::INFERED_IN_PATTERN);
+        }
+
+        if (!initType) {
+            ASSERT(property);
+            return property->TsType();
+        }
+
+        if (property) {
+            return inAssignment ? property->TsType() : CreateUnionType({initType, property->TsType()});
+        }
+
+        return initType;
+    }
+
+    ThrowTypeError({"Property '", name, "' does not exist on type '", inferedType}, locInfo);
+    return nullptr;
+}
+
+Type *Checker::GetVariableTypeInObjectDestructuringWithTargetUnion(const util::StringView &name, UnionType *inferedType,
+                                                                   Type *initType, bool annotationTypeUsed,
+                                                                   const lexer::SourcePosition &locInfo,
+                                                                   bool inAssignment)
+{
+    std::vector<Type *> unionTypes;
+
+    for (auto *it : inferedType->ConstituentTypes()) {
+        if (it->IsObjectType()) {
+            binder::LocalVariable *property = it->AsObjectType()->GetProperty(name);
+
+            if (property) {
+                unionTypes.push_back(property->TsType());
+                property->AddFlag(binder::VariableFlags::INFERED_IN_PATTERN);
+                continue;
+            }
+
+            if (annotationTypeUsed) {
+                ThrowTypeError({"Property '", name, "' does not exist on type '", inferedType}, locInfo);
+            }
+
+            continue;
+        }
+
+        ThrowTypeError({"Property '", name, "' does not exist on type '", inferedType}, locInfo);
+    }
+
+    if (unionTypes.empty()) {
+        ThrowTypeError({"Property '", name, "' does not exist on type '", inferedType}, locInfo);
+    }
+
+    if (initType && !inAssignment) {
+        unionTypes.push_back(initType);
+    }
+
+    return CreateUnionType(std::move(unionTypes));
+}
+
+Type *Checker::GetVariableTypeInArrayDestructuring(Type *inferedType, Type *initType,
+                                                   const lexer::SourcePosition &locInfo, bool inAssignment)
+{
+    if (inferedType->IsUnionType()) {
+        return GetVariableTypeInArrayDestructuringWithTargetUnion(inferedType->AsUnionType(), initType, locInfo,
+                                                                  inAssignment);
+    }
+
+    if (inferedType->IsArrayType()) {
+        if (initType && !inAssignment) {
+            return CreateUnionType({initType, inferedType->AsArrayType()->ElementType()});
+        }
+
+        return inferedType->AsArrayType()->ElementType();
+    }
+
+    if (inferedType->IsObjectType() && inferedType->AsObjectType()->IsTupleType()) {
+        TupleType *inferedTuple = inferedType->AsObjectType()->AsTupleType();
+        Type *iter = inferedTuple->Iterator()->Next();
+
+        if (initType) {
+            if (iter) {
+                return inAssignment ? iter : CreateUnionType({initType, iter});
+            }
+
+            return initType;
+        }
+
+        if (!iter) {
+            ThrowTypeError(
+                "Initializer provides no value for this binding element and the binding element has no default "
+                "value",
+                locInfo);
+        }
+
+        return iter;
+    }
+
+    ThrowTypeError({"Type '", inferedType, "' must have a '[Symbol.Iterator]()' method that returns an interator"},
+                   locInfo);
+    return nullptr;
+}
+
+Type *Checker::GetVariableTypeInArrayDestructuringWithTargetUnion(UnionType *inferedType, Type *initType,
+                                                                  const lexer::SourcePosition &locInfo,
+                                                                  bool inAssignment)
+{
+    std::vector<Type *> unionTypes;
+
+    for (auto *it : inferedType->ConstituentTypes()) {
+        if (it->IsArrayType()) {
+            unionTypes.push_back(it->AsArrayType()->ElementType());
+            continue;
+        }
+
+        if (it->IsObjectType() && it->AsObjectType()->IsTupleType()) {
+            TupleType *tupleType = it->AsObjectType()->AsTupleType();
+            Type *iter = tupleType->Iterator()->Next();
+
+            if (!iter) {
+                continue;
+            }
+
+            unionTypes.push_back(iter);
+            continue;
+        }
+
+        ThrowTypeError({"Type '", inferedType, "' must have a '[Symbol.Iterator]()' method that returns an interator"},
+                       locInfo);
+    }
+
+    if (initType) {
+        unionTypes.push_back(initType);
+    }
+
+    if (unionTypes.empty()) {
+        ThrowTypeError(
+            "Initializer provides no value for this binding element and the binding element has no default "
+            "value",
+            locInfo);
+    }
+
+    if (inAssignment) {
+        unionTypes.pop_back();
+    }
+
+    return CreateUnionType(std::move(unionTypes));
+}
+
+Type *Checker::GetRestElementType(Type *inferedType, binder::Variable *resultVar, DestructuringType destructuringType,
+                                  const lexer::SourcePosition &locInfo, bool inAssignment)
+{
+    Type *restType = nullptr;
+
+    if (destructuringType == DestructuringType::ARRAY_DESTRUCTURING) {
+        restType = GetRestElementTypeInArrayDestructuring(inferedType, locInfo);
+    } else if (destructuringType == DestructuringType::OBJECT_DESTRUCTURING) {
+        restType = GetRestElementTypeInObjectDestructuring(inferedType, locInfo);
+    }
+
+    if (resultVar && !inAssignment) {
+        Type *resolvedType = resultVar->TsType();
+
+        if (resolvedType) {
+            IsTypeIdenticalTo(resolvedType, restType,
+                              {"Subsequent variable declaration must have the same type. Variable '", resultVar->Name(),
+                               "' must be of type '", resolvedType, "', but here has type '", restType, "'."},
+                              locInfo);
+        }
+    }
+
+    return restType;
+}
+
+Type *Checker::GetRestElementTypeInArrayDestructuring(Type *inferedType, const lexer::SourcePosition &locInfo)
+{
+    if (inferedType->IsUnionType()) {
+        bool createArrayType = false;
+
+        for (auto *it : inferedType->AsUnionType()->ConstituentTypes()) {
+            if (it->IsArrayType()) {
+                createArrayType = true;
+                break;
+            }
+
+            if (!it->IsObjectType() || !it->AsObjectType()->IsTupleType()) {
+                ThrowTypeError(
+                    {"Type '", inferedType, "' must have a '[Symbol.Iterator]()' method that returns an interator"},
+                    locInfo);
+            }
+        }
+
+        if (createArrayType) {
+            return CreateArrayTypeForRest(inferedType->AsUnionType());
+        }
+
+        std::vector<Type *> tupleUnion;
+
+        for (auto *it : inferedType->AsUnionType()->ConstituentTypes()) {
+            ASSERT(it->IsObjectType() && it->AsObjectType()->IsTupleType());
+            Type *newTuple = CreateTupleTypeForRest(it->AsObjectType()->AsTupleType()->Iterator());
+            tupleUnion.push_back(newTuple);
+        }
+
+        return CreateUnionType(std::move(tupleUnion));
+    }
+
+    if (inferedType->IsArrayType()) {
+        return inferedType;
+    }
+
+    if (inferedType->IsObjectType() && inferedType->AsObjectType()->IsTupleType()) {
+        return CreateTupleTypeForRest(inferedType->AsObjectType()->AsTupleType()->Iterator());
+    }
+
+    ThrowTypeError({"Type '", inferedType, "' must have a '[Symbol.Iterator]()' method that returns an interator"},
+                   locInfo);
+    return nullptr;
+}
+
+Type *Checker::GetRestElementTypeInObjectDestructuring(Type *inferedType, const lexer::SourcePosition &locInfo)
+{
+    if (inferedType->IsUnionType()) {
+        std::vector<Type *> unionTypes;
+
+        for (auto *it : inferedType->AsUnionType()->ConstituentTypes()) {
+            if (it->IsObjectType()) {
+                unionTypes.push_back(CreateObjectTypeForRest(it->AsObjectType()));
+                continue;
+            }
+
+            ThrowTypeError("Rest types may only be created from object types.", locInfo);
+        }
+
+        return CreateUnionType(std::move(unionTypes));
+    }
+
+    if (inferedType->IsObjectType()) {
+        return CreateObjectTypeForRest(inferedType->AsObjectType());
+    }
+
+    ThrowTypeError("Rest types may only be created from object types.", locInfo);
+    return nullptr;
+}
+
+Type *Checker::CreateObjectTypeForRest(ObjectType *objType)
+{
+    ObjectDescriptor *desc = allocator_->New<ObjectDescriptor>();
+
+    for (auto *it : objType->AsObjectType()->Properties()) {
+        if (!it->HasFlag(binder::VariableFlags::INFERED_IN_PATTERN)) {
+            auto *memberVar = binder::Scope::CreateVar(allocator_, it->Name(), binder::VariableFlags::NONE, nullptr);
+            memberVar->SetTsType(it->TsType());
+            it->RemoveFlag(binder::VariableFlags::INFERED_IN_PATTERN);
+            memberVar->AddFlag(it->Flags());
+            desc->properties.push_back(memberVar);
+        }
+    }
+
+    return allocator_->New<ObjectLiteralType>(desc);
+}
+
+Type *Checker::CreateTupleTypeForRest(TupleTypeIterator *iterator)
+{
+    ObjectDescriptor *desc = allocator_->New<ObjectDescriptor>();
+    TupleElementFlagPool elementFlags;
+    uint32_t index = 0;
+
+    (void)iterator;
+
+    Type *iter = iterator->Next();
+    while (iter) {
+        Type *elementType = iter;
+        ElementFlags memberFlag = ElementFlags::REQUIRED;
+
+        util::StringView memberIndex = util::Helpers::ToStringView(allocator_, index);
+        auto *memberVar = binder::Scope::CreateVar(allocator_, memberIndex, binder::VariableFlags::PROPERTY, nullptr);
+        memberVar->SetTsType(elementType);
+        elementFlags.insert({memberIndex, memberFlag});
+        desc->properties.push_back(memberVar);
+
+        index++;
+        iter = iterator->Next();
+    }
+
+    return CreateTupleType(desc, std::move(elementFlags), ElementFlags::REQUIRED, index, index, false);
+}
+
+Type *Checker::CreateArrayTypeForRest(UnionType *inferedType)
+{
+    std::vector<Type *> unionTypes;
+
+    for (auto *it : inferedType->ConstituentTypes()) {
+        if (it->IsArrayType()) {
+            unionTypes.push_back(it->AsArrayType()->ElementType());
+            continue;
+        }
+
+        if (it->IsObjectType() && it->AsObjectType()->IsTupleType()) {
+            TupleType *currentTuple = it->AsObjectType()->AsTupleType();
+
+            Type *iter = currentTuple->Iterator()->Next();
+            while (iter) {
+                unionTypes.push_back(iter);
+                iter = currentTuple->Iterator()->Next();
+            }
+        }
+    }
+
+    Type *restArrayElementType = CreateUnionType(std::move(unionTypes));
+    return allocator_->New<ArrayType>(restArrayElementType);
+}
+
+Type *Checker::CreateInitializerTypeForPattern(const Type *patternType, const ir::Expression *initNode,
+                                               bool validateCurrent)
+{
+    if (patternType->IsObjectType() && patternType->AsObjectType()->IsObjectLiteralType() &&
+        initNode->IsObjectExpression()) {
+        return CreateInitializerTypeForObjectPattern(patternType->AsObjectType(),
+                                                     const_cast<ir::ObjectExpression *>(initNode->AsObjectExpression()),
+                                                     validateCurrent);
+    }
+
+    if (patternType->IsObjectType() && patternType->AsObjectType()->IsTupleType() && initNode->IsArrayExpression()) {
+        return CreateInitializerTypeForArrayPattern(patternType->AsObjectType()->AsTupleType(),
+                                                    const_cast<ir::ArrayExpression *>(initNode->AsArrayExpression()),
+                                                    validateCurrent);
+    }
+
+    return GetBaseTypeOfLiteralType(CheckTypeCached(initNode));
+}
+
+Type *Checker::CreateInitializerTypeForObjectPattern(const ObjectType *patternType,
+                                                     const ir::ObjectExpression *initNode, bool validateCurrent)
+{
+    ObjectType *initObjectType = initNode->Check(this)->AsObjectType();
+
+    for (auto *it : initNode->AsObjectExpression()->Properties()) {
+        if (it->IsProperty()) {
+            ir::Property *currentProp = it->AsProperty();
+            util::StringView propName =
+                ToPropertyName(currentProp->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME, currentProp->IsComputed());
+
+            binder::Variable *patternProp = patternType->GetProperty(propName);
+
+            if (!patternProp) {
+                if (validateCurrent && !patternType->HasObjectFlag(ObjectType::ObjectFlags::HAVE_REST)) {
+                    ThrowTypeError({"Object literal may only specify known properties, and '", propName,
+                                    "' does not exist in type '", patternType, "'."},
+                                   currentProp->Start());
+                }
+
+                continue;
+            }
+
+            binder::Variable *initProp = initObjectType->GetProperty(propName);
+            ASSERT(initProp);
+
+            initProp->SetTsType(CreateInitializerTypeForPattern(
+                patternProp->TsType(), currentProp->Value(), !patternProp->HasFlag(binder::VariableFlags::OPTIONAL)));
+        }
+    }
+
+    return initObjectType;
+}
+
+Type *Checker::CreateInitializerTypeForArrayPattern(const TupleType *patternType, const ir::ArrayExpression *initNode,
+                                                    bool validateCurrent)
+{
+    if (patternType->Properties().size() == 1 && (patternType->CombinedFlags() & ElementFlags::REST)) {
+        return initNode->Check(this);
+    }
+
+    ObjectType *initTupleType = initNode->Check(this)->AsObjectType()->AsTupleType();
+
+    nodeCache_.insert({initNode, initTupleType});
+
+    for (size_t it = 0; it < initNode->Elements().size(); it++) {
+        if (patternType->FixedLength() < it) {
+            return initTupleType;
+        }
+
+        util::StringView propName = util::Helpers::ToStringView(allocator_, static_cast<uint32_t>(it));
+        binder::Variable *initProp = initTupleType->GetProperty(propName);
+        ASSERT(initProp);
+
+        binder::Variable *patternProp = patternType->GetProperty(propName);
+
+        if (patternProp) {
+            initProp->SetTsType(
+                CreateInitializerTypeForPattern(patternProp->TsType(), initNode->Elements()[it], validateCurrent));
+        }
+    }
+
+    return initTupleType;
+}
+
+bool Checker::ShouldCreatePropertyValueName(const ir::Expression *propValue)
+{
+    return propValue->IsArrayPattern() || propValue->IsObjectPattern() ||
+           (propValue->IsAssignmentPattern() && (propValue->AsAssignmentPattern()->Left()->IsArrayPattern() ||
+                                                 propValue->AsAssignmentPattern()->Left()->IsObjectPattern()));
+}
+
+void Checker::CreatePatternName(const ir::AstNode *node, std::stringstream &ss) const
+{
+    switch (node->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            ss << node->AsIdentifier()->Name();
+            break;
+        }
+        case ir::AstNodeType::ARRAY_PATTERN: {
+            ss << "[";
+
+            const auto &elements = node->AsArrayPattern()->Elements();
+            for (auto it = elements.begin(); it != elements.end(); it++) {
+                Checker::CreatePatternName(*it, ss);
+                if (std::next(it) != elements.end()) {
+                    ss << ", ";
+                }
+            }
+
+            ss << "]";
+            break;
+        }
+        case ir::AstNodeType::OBJECT_PATTERN: {
+            ss << "{ ";
+
+            const auto &properties = node->AsObjectPattern()->Properties();
+            for (auto it = properties.begin(); it != properties.end(); it++) {
+                Checker::CreatePatternName(*it, ss);
+                if (std::next(it) != properties.end()) {
+                    ss << ", ";
+                }
+            }
+
+            ss << " }";
+            break;
+        }
+        case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+            Checker::CreatePatternName(node->AsAssignmentPattern()->Left(), ss);
+            break;
+        }
+        case ir::AstNodeType::PROPERTY: {
+            const ir::Property *prop = node->AsProperty();
+            util::StringView propName;
+
+            if (prop->Key()->IsIdentifier()) {
+                propName = prop->Key()->AsIdentifier()->Name();
+            } else {
+                switch (prop->Key()->Type()) {
+                    case ir::AstNodeType::NUMBER_LITERAL: {
+                        propName =
+                            util::Helpers::ToStringView(allocator_, prop->Key()->AsNumberLiteral()->Number<double>());
+                        break;
+                    }
+                    case ir::AstNodeType::BIGINT_LITERAL: {
+                        propName = prop->Key()->AsBigIntLiteral()->Str();
+                        break;
+                    }
+                    case ir::AstNodeType::STRING_LITERAL: {
+                        propName = prop->Key()->AsStringLiteral()->Str();
+                        break;
+                    }
+                    default: {
+                        UNREACHABLE();
+                        break;
+                    }
+                }
+            }
+
+            ss << propName;
+
+            if (ShouldCreatePropertyValueName(prop->Value())) {
+                ss << ": ";
+                Checker::CreatePatternName(prop->Value(), ss);
+            }
+
+            break;
+        }
+        case ir::AstNodeType::REST_ELEMENT: {
+            ss << "...";
+            Checker::CreatePatternName(node->AsRestElement()->Argument(), ss);
+            break;
+        }
+        case ir::AstNodeType::OMITTED_EXPRESSION: {
+            ss << ", ";
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/function.cpp b/es2panda/typescript/core/function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..09006bd449defc4704f93e031d1a5e6a1f58e62a
--- /dev/null
+++ b/es2panda/typescript/core/function.cpp
@@ -0,0 +1,441 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/callExpression.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/property.h>
+#include <ir/base/spreadElement.h>
+#include <ir/statements/returnStatement.h>
+#include <ir/statements/functionDeclaration.h>
+#include <binder/variable.h>
+#include <binder/scope.h>
+#include <binder/declaration.h>
+
+#include <typescript/checker.h>
+#include <typescript/types/objectDescriptor.h>
+#include <typescript/types/objectType.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace panda::es2panda::checker {
+
+Signature *Checker::HandleFunctionReturn(const ir::ScriptFunction *func, SignatureInfo *signatureInfo,
+                                         binder::Variable *funcVar)
+{
+    // TODO(aszilagyi): this function only works properly for simple functions, have to implement the Async and/or
+    // Generator function part
+    Signature *callSignature = allocator_->New<checker::Signature>(signatureInfo, GlobalAnyType());
+
+    if (funcVar) {
+        Type *funcType = CreateFunctionTypeWithSignature(callSignature);
+        funcType->SetVariable(funcVar);
+        funcVar->SetTsType(funcType);
+        callSignature = funcVar->TsType()->AsObjectType()->CallSignatures()[0];
+    }
+
+    if (func->ReturnTypeAnnotation()) {
+        Type *returnType = func->ReturnTypeAnnotation()->Check(this);
+
+        if (func->IsArrow() && func->Body()->IsExpression() &&
+            !ElaborateElementwise(func->Body()->AsExpression(), returnType, func->Body()->Start())) {
+            Type *bodyType = GetBaseTypeOfLiteralType(func->Body()->Check(this));
+            IsTypeAssignableTo(bodyType, returnType,
+                               {"Type '", bodyType, "' is not assignable to type '", returnType, "'."},
+                               func->Body()->Start());
+        } else if (returnType->IsNeverType()) {
+            ThrowTypeError("A function returning 'never' cannot have a reachable end point.",
+                           func->ReturnTypeAnnotation()->Start());
+        } else if (!MaybeTypeOfKind(returnType, TypeFlag::ANY_OR_VOID)) {
+            CheckAllCodePathsInNonVoidFunctionReturnOrThrow(
+                func, func->ReturnTypeAnnotation()->Start(),
+                "A function whose declared type is neither 'void' nor 'any' must return a value.");
+        }
+
+        callSignature->SetReturnType(returnType);
+    } else if (func->Declare()) {
+        callSignature->SetReturnType(GlobalAnyType());
+    } else if (func->IsArrow() && func->Body()->IsExpression()) {
+        callSignature->SetReturnType(GetBaseTypeOfLiteralType(func->Body()->Check(this)));
+    } else {
+        std::vector<Type *> returnTypes;
+        CollectTypesFromReturnStatements(func->Body(), returnTypes);
+
+        if (returnTypes.empty()) {
+            callSignature->SetReturnType(GlobalVoidType());
+        } else {
+            callSignature->SetReturnType(CreateUnionType(std::move(returnTypes)));
+        }
+    }
+
+    return callSignature;
+}
+
+void Checker::CreateTypeForObjectPatternParameter(ObjectType *patternType, const ir::Expression *patternNode,
+                                                  const ir::Expression *initNode)
+{
+    if (initNode) {
+        ASSERT(initNode->IsObjectExpression());
+        ObjectType *initObjType = CheckTypeCached(initNode)->AsObjectType();
+
+        for (auto *it : initObjType->Properties()) {
+            binder::LocalVariable *foundProp = patternType->GetProperty(it->Name());
+            if (foundProp) {
+                foundProp->SetTsType(it->TsType());
+            }
+        }
+    }
+
+    for (auto *it : patternNode->AsObjectPattern()->Properties()) {
+        if (it->IsProperty() && it->AsProperty()->Value()->IsAssignmentPattern() &&
+            !it->AsProperty()->Value()->AsAssignmentPattern()->Left()->IsIdentifier()) {
+            const ir::AssignmentExpression *assignmentPattern = it->AsProperty()->Value()->AsAssignmentPattern();
+
+            binder::LocalVariable *foundProp =
+                patternType->GetProperty(ToPropertyName(it->AsProperty()->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME));
+
+            foundProp->SetTsType(CreateTypeForPatternParameter(assignmentPattern->Left(), assignmentPattern->Right()));
+        }
+    }
+}
+
+Type *Checker::CreateTypeForPatternParameter(const ir::Expression *patternNode, const ir::Expression *initNode)
+{
+    Type *paramType = CheckTypeCached(patternNode);
+
+    if (patternNode->IsObjectPattern()) {
+        ASSERT(paramType->IsObjectType());
+        CreateTypeForObjectPatternParameter(paramType->AsObjectType(), patternNode, initNode);
+    }
+
+    if (patternNode->IsArrayPattern() && initNode) {
+        ASSERT(initNode->IsArrayExpression() && paramType->IsObjectType() && paramType->AsObjectType()->IsTupleType());
+
+        paramType = CheckTypeCached(initNode);
+
+        for (size_t it = 0; it < paramType->AsObjectType()->Properties().size(); it++) {
+            if (it < patternNode->AsArrayPattern()->Elements().size()) {
+                const ir::Expression *patternElement = patternNode->AsArrayPattern()->Elements()[it];
+
+                if (patternElement->IsArrayPattern() || patternElement->IsObjectPattern()) {
+                    paramType->AsObjectType()->Properties()[it]->SetTsType(
+                        CreateTypeForPatternParameter(patternElement, initNode->AsArrayExpression()->Elements()[it]));
+                }
+            }
+        }
+    }
+
+    return paramType;
+}
+
+void Checker::CheckFunctionParameterDeclaration(const ArenaVector<ir::Expression *> &params,
+                                                SignatureInfo *signatureInfo)
+{
+    signatureInfo->restVar = nullptr;
+    signatureInfo->minArgCount = 0;
+
+    for (auto *it : params) {
+        FunctionParameterInfo paramInfo = GetFunctionParameterInfo(it);
+
+        VariableBindingContext context = VariableBindingContext::REGULAR;
+
+        Type *annotationType = paramInfo.typeAnnotation ? CheckTypeCached(paramInfo.typeAnnotation) : nullptr;
+
+        TypeOrNode elaborateSource;
+
+        if (paramInfo.initNode && annotationType) {
+            elaborateSource = paramInfo.initNode;
+            if (!ElaborateElementwise(elaborateSource, annotationType, it->Start()) &&
+                !IsTypeAssignableTo(paramInfo.initType, annotationType)) {
+                ThrowTypeError(
+                    {"Type '", AsSrc(paramInfo.initType), "' is not assignable to type '", annotationType, "'"},
+                    it->Start());
+            }
+        }
+
+        Type *patternType = paramInfo.destructuringType != DestructuringType::NO_DESTRUCTURING
+                                ? paramInfo.bindingNode->Check(this)
+                                : nullptr;
+
+        if (patternType) {
+            if (annotationType) {
+                elaborateSource = patternType;
+                ElaborateElementwise(elaborateSource, annotationType, it->Start());
+            } else if (paramInfo.initNode) {
+                paramInfo.initType = CreateInitializerTypeForPattern(patternType, paramInfo.initNode);
+            }
+        }
+
+        Type *paramType = GetParamTypeFromParamInfo(paramInfo, annotationType, patternType);
+
+        HandleVariableDeclarationWithContext(paramInfo.bindingNode, paramType, context, paramInfo.destructuringType,
+                                             paramInfo.typeAnnotation);
+
+        // TODO(aszilagyi): get the variable from the function scope
+        binder::LocalVariable *paramVar = nullptr;
+
+        paramType = paramInfo.destructuringType != DestructuringType::NO_DESTRUCTURING
+                        ? CreateTypeForPatternParameter(paramInfo.bindingNode, paramInfo.initNode)
+                        : paramType;
+
+        paramType->SetVariable(paramVar);
+        paramVar->SetTsType(paramType);
+
+        if (paramInfo.restType) {
+            signatureInfo->restVar = paramVar;
+            continue;
+        }
+
+        if (!paramInfo.optionalParam) {
+            signatureInfo->minArgCount++;
+        } else {
+            paramVar->AddFlag(binder::VariableFlags::OPTIONAL);
+        }
+
+        signatureInfo->funcParams.push_back(paramVar);
+    }
+}
+
+void Checker::InferFunctionDeclarationType(const binder::FunctionDecl *decl, binder::Variable *funcVar)
+{
+    ObjectDescriptor *descWithOverload = allocator_->New<ObjectDescriptor>();
+
+    for (const auto *it : decl->Decls()) {
+        const ir::ScriptFunction *func = it->Function();
+
+        if (func->IsOverload() && !func->Declare()) {
+            ScopeContext scopeCtx(this, func->Scope());
+
+            auto *signatureInfo = allocator_->New<checker::SignatureInfo>();
+            CheckFunctionParameterDeclaration(func->Params(), signatureInfo);
+            Type *returnType = GlobalAnyType();
+
+            if (func->ReturnTypeAnnotation()) {
+                returnType = func->ReturnTypeAnnotation()->Check(this);
+            }
+
+            Signature *overloadSignature = allocator_->New<Signature>(signatureInfo, returnType);
+
+            descWithOverload->callSignatures.push_back(overloadSignature);
+
+            continue;
+        }
+
+        if (descWithOverload->callSignatures.empty()) {
+            ScopeContext scopeCtx(this, func->Scope());
+
+            auto *signatureInfo = allocator_->New<checker::SignatureInfo>();
+            CheckFunctionParameterDeclaration(func->Params(), signatureInfo);
+
+            HandleFunctionReturn(func, signatureInfo, funcVar);
+            return;
+        }
+
+        Type *funcType = allocator_->New<FunctionType>(descWithOverload);
+        funcType->SetVariable(funcVar);
+        funcVar->SetTsType(funcType);
+
+        ScopeContext scopeCtx(this, func->Scope());
+
+        auto *signatureInfo = allocator_->New<checker::SignatureInfo>();
+        CheckFunctionParameterDeclaration(func->Params(), signatureInfo);
+
+        Signature *baseCallSignature = HandleFunctionReturn(func, signatureInfo);
+
+        for (auto *iter : funcType->AsObjectType()->CallSignatures()) {
+            if (baseCallSignature->ReturnType()->IsVoidType() ||
+                IsTypeAssignableTo(baseCallSignature->ReturnType(), iter->ReturnType()) ||
+                IsTypeAssignableTo(iter->ReturnType(), baseCallSignature->ReturnType())) {
+                baseCallSignature->AssignmentTarget(relation_, iter);
+
+                if (relation_->IsTrue()) {
+                    continue;
+                }
+            }
+
+            ThrowTypeError("This overload signature is not compatible with its implementation signature",
+                           func->Start());
+        }
+
+        return;
+    }
+}
+
+void Checker::CollectTypesFromReturnStatements(const ir::AstNode *parent, std::vector<Type *> &returnTypes)
+{
+    parent->Iterate([this, &returnTypes](ir::AstNode *childNode) -> void {
+        if (childNode->IsScriptFunction()) {
+            return;
+        }
+
+        if (childNode->IsReturnStatement()) {
+            ir::ReturnStatement *returnStmt = childNode->AsReturnStatement();
+
+            if (!returnStmt->Argument()) {
+                return;
+            }
+
+            returnTypes.push_back(GetBaseTypeOfLiteralType(childNode->AsReturnStatement()->Argument()->Check(this)));
+        }
+
+        CollectTypesFromReturnStatements(childNode, returnTypes);
+    });
+}
+
+static bool SearchForReturnOrThrow(const ir::AstNode *parent)
+{
+    bool found = false;
+
+    parent->Iterate([&found](const ir::AstNode *childNode) -> void {
+        if (childNode->IsThrowStatement() || childNode->IsReturnStatement()) {
+            found = true;
+            return;
+        }
+
+        if (childNode->IsScriptFunction()) {
+            return;
+        }
+
+        SearchForReturnOrThrow(childNode);
+    });
+
+    return found;
+}
+
+void Checker::CheckAllCodePathsInNonVoidFunctionReturnOrThrow(const ir::ScriptFunction *func,
+                                                              lexer::SourcePosition lineInfo, const char *errMsg)
+{
+    if (!SearchForReturnOrThrow(func->Body())) {
+        ThrowTypeError(errMsg, lineInfo);
+    }
+    // TODO(aszilagyi): this function is not fully implement the TSC one, in the future if we will have a
+    // noImplicitReturn compiler option for TypeScript we should update this function
+}
+
+FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
+{
+    std::stringstream ss;
+    FunctionParameterInfo paramInfo;
+    paramInfo.bindingNode = expr;
+
+    if (expr->IsArrayPattern()) {
+        paramInfo.typeAnnotation = expr->AsArrayPattern()->TypeAnnotation();
+        paramInfo.destructuringType = DestructuringType::ARRAY_DESTRUCTURING;
+        CreatePatternName(expr, ss);
+        util::UString pn(ss.str(), allocator_);
+        paramInfo.paramName = pn.View();
+        return paramInfo;
+    }
+
+    if (expr->IsObjectPattern()) {
+        paramInfo.typeAnnotation = expr->AsObjectPattern()->TypeAnnotation();
+        paramInfo.destructuringType = DestructuringType::OBJECT_DESTRUCTURING;
+        CreatePatternName(expr, ss);
+        util::UString pn(ss.str(), allocator_);
+        paramInfo.paramName = pn.View();
+        return paramInfo;
+    }
+
+    if (expr->IsAssignmentPattern()) {
+        ir::AssignmentExpression *assignmentPattern = expr->AsAssignmentPattern();
+        paramInfo.initNode = assignmentPattern->Right();
+        paramInfo.bindingNode = assignmentPattern->Left();
+        paramInfo.optionalParam = true;
+
+        if (paramInfo.bindingNode->IsArrayPattern()) {
+            paramInfo.typeAnnotation = paramInfo.bindingNode->AsArrayPattern()->TypeAnnotation();
+            // TODO(aszilagyi): 1st param true
+            paramInfo.initType = expr->AsAssignmentPattern()->Right()->Check(this);
+            paramInfo.destructuringType = DestructuringType::ARRAY_DESTRUCTURING;
+            CreatePatternName(expr, ss);
+            util::UString pn(ss.str(), allocator_);
+            paramInfo.paramName = pn.View();
+        } else {
+            if (paramInfo.bindingNode->IsObjectPattern()) {
+                paramInfo.typeAnnotation = paramInfo.bindingNode->AsObjectPattern()->TypeAnnotation();
+                paramInfo.destructuringType = DestructuringType::OBJECT_DESTRUCTURING;
+                CreatePatternName(expr, ss);
+                util::UString pn(ss.str(), allocator_);
+                paramInfo.paramName = pn.View();
+            } else {
+                ASSERT(paramInfo.bindingNode->IsIdentifier());
+                paramInfo.typeAnnotation = paramInfo.bindingNode->AsIdentifier()->TypeAnnotation();
+                paramInfo.paramName = paramInfo.bindingNode->AsIdentifier()->Name();
+            }
+
+            paramInfo.initType = expr->AsAssignmentPattern()->Right()->Check(this);
+        }
+
+        return paramInfo;
+    }
+
+    if (expr->IsRestElement()) {
+        ir::SpreadElement *restElement = expr->AsRestElement();
+        paramInfo.restType = GlobalAnyType();
+
+        if (restElement->TypeAnnotation()) {
+            Type *restArrayType = restElement->TypeAnnotation()->Check(this);
+
+            if (!restArrayType->IsArrayType()) {
+                ThrowTypeError("A rest parameter must be of an array type", expr->Start());
+            }
+
+            paramInfo.restType = restArrayType->AsArrayType()->ElementType();
+        }
+
+        paramInfo.paramName = restElement->Argument()->AsIdentifier()->Name();
+        paramInfo.bindingNode = restElement->Argument();
+
+        return paramInfo;
+    }
+
+    ASSERT(expr->IsIdentifier());
+    paramInfo.typeAnnotation = expr->AsIdentifier()->TypeAnnotation();
+    paramInfo.optionalParam = expr->AsIdentifier()->IsOptional();
+    paramInfo.paramName = expr->AsIdentifier()->Name();
+
+    return paramInfo;
+}
+
+Type *Checker::GetParamTypeFromParamInfo(const FunctionParameterInfo &paramInfo, Type *annotationType,
+                                         Type *patternType)
+{
+    if (paramInfo.typeAnnotation) {
+        return annotationType;
+    }
+
+    if (paramInfo.initType) {
+        return paramInfo.initType;
+    }
+
+    if (patternType) {
+        return patternType;
+    }
+
+    if (paramInfo.restType) {
+        return paramInfo.restType;
+    }
+
+    return GlobalAnyType();
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/generics.cpp b/es2panda/typescript/core/generics.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b3ee8bb7f3e781bedf6d124f3b79050def368c84
--- /dev/null
+++ b/es2panda/typescript/core/generics.cpp
@@ -0,0 +1,293 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/ts/tsTypeAliasDeclaration.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+#include <ir/ts/tsTypeParameterInstantiation.h>
+#include <ir/ts/tsInterfaceDeclaration.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <ir/ts/tsTypeReference.h>
+#include <ir/expressions/identifier.h>
+
+#include <binder/variable.h>
+#include <binder/scope.h>
+#include <binder/declaration.h>
+
+#include <typescript/checker.h>
+
+namespace panda::es2panda::checker {
+
+void Checker::ValidateTypeParameterInstantiation(size_t typeArgumentCount, size_t minTypeArgumentCount,
+                                                 size_t numOfTypeArguments, const util::StringView &name,
+                                                 const lexer::SourcePosition &locInfo)
+{
+    if (numOfTypeArguments < minTypeArgumentCount || numOfTypeArguments > typeArgumentCount) {
+        if (minTypeArgumentCount == typeArgumentCount) {
+            ThrowTypeError({"Generic type '", name, "' requires '", minTypeArgumentCount, "' type argument(s)."},
+                           locInfo);
+        }
+
+        ThrowTypeError({"Generic type '", name, "' requires between '", minTypeArgumentCount, "' and '",
+                        typeArgumentCount, "' type arguments."},
+                       locInfo);
+    }
+}
+
+Type *Checker::InstantiateGenericTypeAlias(binder::Variable *bindingVar, const ir::TSTypeParameterDeclaration *decl,
+                                           const ir::TSTypeParameterInstantiation *typeParams,
+                                           const lexer::SourcePosition &locInfo)
+{
+    ValidateTypeParameterInstantiation(decl->Params().size(), decl->RequiredParams(),
+                                       typeParams ? typeParams->Params().size() : 0, bindingVar->Name(), locInfo);
+
+    std::vector<std::pair<TypeParameter *, Type *>> savedDefaultTypes;
+
+    if (typeParams) {
+        ScopeContext scopeCtx(this, decl->Scope());
+
+        for (size_t it = 0; it < typeParams->Params().size(); it++) {
+            binder::ScopeFindResult res = scope_->Find(decl->Params()[it]->Name()->Name());
+
+            ASSERT(res.variable && res.variable->TsType() && res.variable->TsType()->IsTypeParameter());
+
+            TypeParameter *currentTypeParameterType = res.variable->TsType()->AsTypeParameter();
+
+            savedDefaultTypes.emplace_back(currentTypeParameterType, currentTypeParameterType->DefaultType());
+
+            currentTypeParameterType->SetDefaultType(typeParams->Params()[it]->Check(this));
+        }
+    }
+
+    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, globalTypes_);
+
+    for (auto it : savedDefaultTypes) {
+        it.first->SetDefaultType(it.second);
+    }
+
+    return newGenericType;
+}
+
+Type *Checker::InstantiateGenericInterface(binder::Variable *bindingVar, const binder::Decl *decl,
+                                           const ir::TSTypeParameterInstantiation *typeParams,
+                                           const lexer::SourcePosition &locInfo)
+{
+    const std::pair<std::vector<binder::Variable *>, size_t> &mergedTypeParams =
+        bindingVar->TsType()->AsObjectType()->AsInterfaceType()->GetMergedTypeParams();
+
+    ValidateTypeParameterInstantiation(mergedTypeParams.first.size(), mergedTypeParams.second,
+                                       typeParams ? typeParams->Params().size() : 0, bindingVar->Name(), locInfo);
+
+    std::vector<Type *> typeParamInstantiationTypes;
+
+    if (typeParams) {
+        for (auto *it : typeParams->Params()) {
+            typeParamInstantiationTypes.push_back(it->Check(this));
+        }
+    }
+
+    std::vector<std::pair<TypeParameter *, Type *>> savedDefaultTypes;
+
+    for (size_t i = 0; i < typeParamInstantiationTypes.size(); i++) {
+        TypeParameter *mergedTypeParam = mergedTypeParams.first[i]->TsType()->AsTypeParameter();
+
+        savedDefaultTypes.emplace_back(mergedTypeParam, mergedTypeParam->DefaultType());
+
+        mergedTypeParam->SetDefaultType(typeParamInstantiationTypes[i]);
+    }
+
+    const auto &declarations = decl->AsInterfaceDecl()->Decls();
+
+    for (const auto *it : declarations) {
+        const ir::TSInterfaceDeclaration *currentDecl = it->AsTSInterfaceDeclaration();
+
+        if (!currentDecl->TypeParams()) {
+            continue;
+        }
+
+        const ir::TSTypeParameterDeclaration *currentTypeParams = currentDecl->TypeParams();
+
+        ScopeContext scopeCtx(this, currentTypeParams->Scope());
+
+        for (size_t i = 0; i < currentTypeParams->Params().size(); i++) {
+            binder::ScopeFindResult res = scope_->Find(currentTypeParams->Params()[i]->Name()->Name());
+
+            ASSERT(res.variable && res.variable->TsType() && res.variable->TsType()->IsTypeParameter());
+
+            TypeParameter *currentTypeParameterType = res.variable->TsType()->AsTypeParameter();
+
+            savedDefaultTypes.emplace_back(currentTypeParameterType, currentTypeParameterType->DefaultType());
+
+            currentTypeParameterType->SetDefaultType(
+                mergedTypeParams.first[i]->TsType()->AsTypeParameter()->DefaultType());
+        }
+    }
+
+    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, globalTypes_);
+
+    newGenericType->AsObjectType()->AsInterfaceType()->SetTypeParamTypes(std::move(typeParamInstantiationTypes));
+
+    for (auto it = savedDefaultTypes.rbegin(); it != savedDefaultTypes.rend(); it++) {
+        (*it).first->SetDefaultType((*it).second);
+    }
+
+    return newGenericType;
+}
+
+void Checker::CheckTypeParametersNotReferenced(const ir::AstNode *parent,
+                                               const ir::TSTypeParameterDeclaration *typeParams, size_t index)
+{
+    parent->Iterate([this, typeParams, index](ir::AstNode *childNode) -> void {
+        if (childNode->IsTSTypeReference() && childNode->AsTSTypeReference()->TypeName()->IsIdentifier()) {
+            const util::StringView &defaultTypeName =
+                childNode->AsTSTypeReference()->TypeName()->AsIdentifier()->Name();
+
+            for (size_t i = index; i < typeParams->Params().size(); i++) {
+                const ir::TSTypeParameter *currentParam = typeParams->Params()[i];
+
+                if (currentParam->Name()->Name() == defaultTypeName) {
+                    ThrowTypeError("Type paremeter defaults can only reference previously declared type parameters.",
+                                   childNode->Start());
+                }
+            }
+        }
+
+        CheckTypeParametersNotReferenced(childNode, typeParams, index);
+    });
+}
+
+std::vector<binder::Variable *> Checker::CheckTypeParameters(const ir::TSTypeParameterDeclaration *typeParams)
+{
+    ScopeContext scopeCtx(this, typeParams->Scope());
+    std::vector<binder::Variable *> params;
+
+    for (size_t i = 0; i < typeParams->Params().size(); i++) {
+        const ir::TSTypeParameter *currentParam = typeParams->Params()[i];
+
+        binder::ScopeFindResult res = scope_->Find(currentParam->Name()->Name());
+        ASSERT(res.variable);
+
+        if (!res.variable->TsType()) {
+            Type *defaultType = nullptr;
+            if (currentParam->DefaultType()) {
+                CheckTypeParametersNotReferenced(currentParam->DefaultType(), typeParams, i + 1);
+
+                if (!typeStack_.insert(currentParam->DefaultType()).second) {
+                    ThrowTypeError({"Type parameter '", currentParam->Name()->Name(), "' has a circular default."},
+                                   currentParam->DefaultType()->Start());
+                }
+
+                defaultType = currentParam->DefaultType()->Check(this);
+
+                typeStack_.erase(currentParam->DefaultType());
+            }
+
+            // TODO(aszilagyi): handle type parameter constraints
+            auto *paramType = allocator_->New<TypeParameter>(nullptr, defaultType);
+
+            res.variable->SetTsType(paramType);
+        }
+
+        params.push_back(res.variable);
+    }
+
+    return params;
+}
+
+std::pair<std::vector<binder::Variable *>, size_t> Checker::CollectTypeParametersFromDeclarations(
+    const ArenaVector<ir::TSInterfaceDeclaration *> &declarations)
+{
+    std::pair<std::vector<binder::Variable *>, size_t> collectedTypeParams;
+
+    for (const auto *decl : declarations) {
+        ASSERT(decl->IsTSInterfaceDeclaration());
+
+        const ir::TSInterfaceDeclaration *interfaceDecl = decl->AsTSInterfaceDeclaration();
+
+        if (!interfaceDecl->TypeParams()) {
+            continue;
+        }
+
+        std::vector<binder::Variable *> currentParams = CheckTypeParameters(interfaceDecl->TypeParams());
+
+        for (auto *currentParam : currentParams) {
+            bool addParam = true;
+
+            for (auto &collectedTypeParam : collectedTypeParams.first) {
+                if (currentParam->Name() != collectedTypeParam->Name()) {
+                    continue;
+                }
+
+                if (currentParam->Name() == collectedTypeParam->Name()) {
+                    if (!collectedTypeParam->TsType()->AsTypeParameter()->DefaultType() &&
+                        currentParam->TsType()->AsTypeParameter()->DefaultType()) {
+                        collectedTypeParam = currentParam;
+                    }
+
+                    addParam = false;
+                    break;
+                }
+            }
+
+            if (addParam) {
+                collectedTypeParams.first.push_back(currentParam);
+            }
+        }
+    }
+
+    size_t minTypeArgumentCount = 0;
+
+    for (size_t i = 0; i < collectedTypeParams.first.size(); i++) {
+        if (!collectedTypeParams.first[i]->TsType()->AsTypeParameter()->DefaultType()) {
+            minTypeArgumentCount = i + 1;
+        }
+    }
+
+    collectedTypeParams.second = minTypeArgumentCount;
+
+    return collectedTypeParams;
+}
+
+bool Checker::CheckTypeParametersAreIdentical(
+    const std::pair<std::vector<binder::Variable *>, size_t> &collectedTypeParams,
+    std::vector<binder::Variable *> &currentTypeParams) const
+{
+    size_t maxTypeArgumentCount = collectedTypeParams.first.size();
+    size_t minTypeArgumentCount = collectedTypeParams.second;
+
+    size_t numTypeParameters = currentTypeParams.size();
+    if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) {
+        return true;
+    }
+
+    for (size_t i = 0; i < currentTypeParams.size(); i++) {
+        binder::Variable *sourceParam = currentTypeParams[i];
+        binder::Variable *targetParam = collectedTypeParams.first[i];
+
+        if (sourceParam->Name() != targetParam->Name()) {
+            return true;
+        }
+
+        Type *sourceDefaultType = sourceParam->TsType()->AsTypeParameter()->DefaultType();
+        Type *targetDefaultType = targetParam->TsType()->AsTypeParameter()->DefaultType();
+
+        if (sourceDefaultType && targetDefaultType && !IsTypeIdenticalTo(sourceDefaultType, targetDefaultType)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/helpers.cpp b/es2panda/typescript/core/helpers.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..18d6640aa6f30463d60fda0df39fc126141f0a34
--- /dev/null
+++ b/es2panda/typescript/core/helpers.cpp
@@ -0,0 +1,311 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/binaryExpression.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/ts/tsQualifiedName.h>
+#include <ir/ts/tsTypeParameterDeclaration.h>
+#include <ir/ts/tsTypeParameter.h>
+#include <binder/variable.h>
+#include <binder/scope.h>
+
+#include <typescript/checker.h>
+
+namespace panda::es2panda::checker {
+
+const ir::TSQualifiedName *Checker::ResolveLeftMostQualifiedName(const ir::TSQualifiedName *qualifiedName)
+{
+    const ir::TSQualifiedName *iter = qualifiedName;
+
+    while (iter->Left()->IsTSQualifiedName()) {
+        iter = iter->Left()->AsTSQualifiedName();
+    }
+
+    return iter;
+}
+
+const ir::MemberExpression *Checker::ResolveLeftMostMemberExpression(const ir::MemberExpression *expr)
+{
+    const ir::MemberExpression *iter = expr;
+
+    while (iter->Object()->IsMemberExpression()) {
+        iter = iter->Object()->AsMemberExpression();
+    }
+
+    return iter;
+}
+
+void Checker::CheckReferenceExpression(const ir::Expression *expr, const char *invalidReferenceMsg,
+                                       const char *invalidOptionalChainMsg)
+{
+    if (expr->IsIdentifier()) {
+        const util::StringView &name = expr->AsIdentifier()->Name();
+        binder::ScopeFindResult result = scope_->Find(name);
+        ASSERT(result.variable);
+
+        if (result.variable->HasFlag(binder::VariableFlags::ENUM_LITERAL)) {
+            ThrowTypeError({"Cannot assign to '", name, "' because it is not a variable."}, expr->Start());
+        }
+    } else if (!expr->IsMemberExpression()) {
+        if (expr->IsChainExpression()) {
+            ThrowTypeError(invalidOptionalChainMsg, expr->Start());
+        }
+
+        ThrowTypeError(invalidReferenceMsg, expr->Start());
+    }
+}
+
+void Checker::CheckTestingKnownTruthyCallableOrAwaitableType(const ir::Expression *condExpr, Type *type,
+                                                             const ir::AstNode *body)
+{
+    if (GetFalsyFlags(type) != TypeFlag::NONE) {
+        return;
+    }
+
+    const ir::AstNode *location = condExpr;
+    if (condExpr->IsBinaryExpression()) {
+        location = condExpr->AsBinaryExpression()->Right();
+    } else if (condExpr->IsAssignmentExpression()) {
+        location = condExpr->AsAssignmentExpression()->Right();
+    }
+
+    binder::Variable *testVar = nullptr;
+    binder::ScopeFindResult result {};
+
+    if (location->IsIdentifier()) {
+        result = scope_->Find(location->AsIdentifier()->Name(), binder::ResolveBindingOptions::ALL);
+        ASSERT(result.variable);
+        testVar = result.variable;
+    } else if (location->IsBinaryExpression() && location->AsBinaryExpression()->Right()->IsIdentifier()) {
+        result = scope_->Find(location->AsBinaryExpression()->Right()->AsIdentifier()->Name(),
+                              binder::ResolveBindingOptions::ALL);
+        ASSERT(result.variable);
+        testVar = result.variable;
+    } else if (location->IsAssignmentExpression() && location->AsAssignmentExpression()->Right()->IsIdentifier()) {
+        result = scope_->Find(location->AsAssignmentExpression()->Right()->AsIdentifier()->Name(),
+                              binder::ResolveBindingOptions::ALL);
+        ASSERT(result.variable);
+        testVar = result.variable;
+    } else if (location->IsMemberExpression() && !location->AsMemberExpression()->IsComputed()) {
+        testVar = ResolveNonComputedObjectProperty(location->AsMemberExpression());
+    }
+
+    if (!testVar) {
+        return;
+    }
+
+    if (testVar->TsType() && testVar->TsType()->IsObjectType() &&
+        !testVar->TsType()->AsObjectType()->CallSignatures().empty()) {
+        if (condExpr->Parent()->IsBinaryExpression() &&
+            IsVariableUsedInBinaryExpressionChain(condExpr->Parent(), testVar) &&
+            IsVariableUsedInConditionBody(body, testVar)) {
+            ThrowTypeError(
+                "This condition will always return true since this function appears to always be defined. "
+                "Did "
+                "you mean to call it insted?",
+                location->Start());
+        }
+    }
+}
+
+Type *Checker::ExtractDefinitelyFalsyTypes(Type *type)
+{
+    if (type->IsStringType()) {
+        return GlobalEmptyStringType();
+    }
+
+    if (type->IsNumberType()) {
+        return GlobalZeroType();
+    }
+
+    if (type->IsBigintType()) {
+        return GlobalZeroBigintType();
+    }
+
+    if (type == GlobalFalseType() || type->HasTypeFlag(TypeFlag::NULLABLE) ||
+        type->HasTypeFlag(TypeFlag::ANY_OR_UNKNOWN) || type->HasTypeFlag(TypeFlag::VOID) ||
+        (type->IsStringLiteralType() && IsTypeIdenticalTo(type, GlobalEmptyStringType())) ||
+        (type->IsNumberLiteralType() && IsTypeIdenticalTo(type, GlobalZeroType())) ||
+        (type->IsBigintLiteralType() && IsTypeIdenticalTo(type, GlobalZeroBigintType()))) {
+        return type;
+    }
+
+    if (type->IsUnionType()) {
+        std::vector<Type *> &constituentTypes = type->AsUnionType()->ConstituentTypes();
+        std::vector<Type *> newConstituentTypes;
+
+        newConstituentTypes.reserve(constituentTypes.size());
+        for (auto &it : constituentTypes) {
+            newConstituentTypes.push_back(ExtractDefinitelyFalsyTypes(it));
+        }
+
+        return CreateUnionType(std::move(newConstituentTypes));
+    }
+
+    return GlobalNeverType();
+}
+
+Type *Checker::RemoveDefinitelyFalsyTypes(Type *type)
+{
+    if (static_cast<uint64_t>(GetFalsyFlags(type)) & static_cast<uint64_t>(TypeFlag::DEFINITELY_FALSY)) {
+        if (type->IsUnionType()) {
+            std::vector<Type *> &constituentTypes = type->AsUnionType()->ConstituentTypes();
+            std::vector<Type *> newConstituentTypes;
+
+            for (auto &it : constituentTypes) {
+                if (!(static_cast<uint64_t>(GetFalsyFlags(it)) & static_cast<uint64_t>(TypeFlag::DEFINITELY_FALSY))) {
+                    newConstituentTypes.push_back(it);
+                }
+            }
+
+            if (newConstituentTypes.empty()) {
+                return GlobalNeverType();
+            }
+
+            if (newConstituentTypes.size() == 1) {
+                return newConstituentTypes[0];
+            }
+
+            return CreateUnionType(std::move(newConstituentTypes));
+        }
+
+        return GlobalNeverType();
+    }
+
+    return type;
+}
+
+TypeFlag Checker::GetFalsyFlags(Type *type)
+{
+    if (type->IsStringLiteralType()) {
+        return type->AsStringLiteralType()->Value().Empty() ? TypeFlag::STRING_LITERAL : TypeFlag::NONE;
+    }
+
+    if (type->IsNumberLiteralType()) {
+        return type->AsNumberLiteralType()->Value() == 0 ? TypeFlag::NUMBER_LITERAL : TypeFlag::NONE;
+    }
+
+    if (type->IsBigintLiteralType()) {
+        return type->AsBigintLiteralType()->Value() == "0n" ? TypeFlag::BIGINT_LITERAL : TypeFlag::NONE;
+    }
+
+    if (type->IsBooleanLiteralType()) {
+        return type->AsBooleanLiteralType()->Value() ? TypeFlag::NONE : TypeFlag::BOOLEAN_LITERAL;
+    }
+
+    if (type->IsUnionType()) {
+        std::vector<Type *> &constituentTypes = type->AsUnionType()->ConstituentTypes();
+        TypeFlag returnFlag = TypeFlag::NONE;
+
+        for (auto &it : constituentTypes) {
+            returnFlag |= GetFalsyFlags(it);
+        }
+
+        return returnFlag;
+    }
+
+    return static_cast<TypeFlag>(type->TypeFlags() & TypeFlag::POSSIBLY_FALSY);
+}
+
+bool Checker::IsVariableUsedInConditionBody(const ir::AstNode *parent, binder::Variable *searchVar)
+{
+    bool found = false;
+
+    parent->Iterate([this, searchVar, &found](const ir::AstNode *childNode) -> void {
+        binder::Variable *resultVar = nullptr;
+        if (childNode->IsMemberExpression()) {
+            resultVar = ResolveNonComputedObjectProperty(childNode->AsMemberExpression());
+        } else if (childNode->IsIdentifier()) {
+            binder::ScopeFindResult result = scope_->Find(childNode->AsIdentifier()->Name());
+            ASSERT(result.variable);
+            resultVar = result.variable;
+        }
+
+        if (searchVar == resultVar) {
+            found = true;
+            return;
+        }
+
+        if (!childNode->IsMemberExpression()) {
+            IsVariableUsedInConditionBody(childNode, searchVar);
+        }
+    });
+
+    return found;
+}
+
+bool Checker::FindVariableInBinaryExpressionChain(const ir::AstNode *parent, binder::Variable *searchVar)
+{
+    bool found = false;
+
+    parent->Iterate([this, searchVar, &found](const ir::AstNode *childNode) -> void {
+        if (childNode->IsIdentifier()) {
+            binder::ScopeFindResult result = scope_->Find(childNode->AsIdentifier()->Name());
+            ASSERT(result.variable);
+            if (result.variable == searchVar) {
+                found = true;
+                return;
+            }
+        }
+
+        FindVariableInBinaryExpressionChain(childNode, searchVar);
+    });
+
+    return found;
+}
+
+bool Checker::IsVariableUsedInBinaryExpressionChain(const ir::AstNode *parent, binder::Variable *searchVar)
+{
+    while (parent->IsBinaryExpression() &&
+           parent->AsBinaryExpression()->OperatorType() == lexer::TokenType::PUNCTUATOR_LOGICAL_AND) {
+        if (FindVariableInBinaryExpressionChain(parent, searchVar)) {
+            return true;
+        }
+
+        parent = parent->Parent();
+    }
+
+    return false;
+}
+
+Type *Checker::CreateTupleTypeFromEveryArrayExpression(const ir::Expression *expr)
+{
+    status_ |= CheckerStatus::FORCE_TUPLE;
+
+    Type *returnType = expr->Check(this);
+
+    status_ &= ~CheckerStatus::FORCE_TUPLE;
+
+    return returnType;
+}
+
+void Checker::ThrowBinaryLikeError(lexer::TokenType op, Type *leftType, Type *rightType, lexer::SourcePosition lineInfo)
+{
+    ThrowTypeError({"operator ", op, " cannot be applied to types ", leftType, " and ", rightType}, lineInfo);
+}
+
+void Checker::ThrowAssignmentError(Type *leftType, Type *rightType, lexer::SourcePosition lineInfo,
+                                   bool isAsSrcLeftType)
+{
+    if (isAsSrcLeftType) {
+        ThrowTypeError({"Type '", AsSrc(leftType), "' is not assignable to type '", rightType, "'."}, lineInfo);
+    } else {
+        ThrowTypeError({"Type '", leftType, "' is not assignable to type '", rightType, "'."}, lineInfo);
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/object.cpp b/es2panda/typescript/core/object.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..917e5b2ab6f1d10db8a7addea378f9776fdfb39f
--- /dev/null
+++ b/es2panda/typescript/core/object.cpp
@@ -0,0 +1,761 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/expressions/literals/bigIntLiteral.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/functionExpression.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/base/property.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/spreadElement.h>
+#include <ir/ts/tsIndexSignature.h>
+#include <ir/ts/tsMethodSignature.h>
+#include <ir/ts/tsPropertySignature.h>
+#include <ir/ts/tsSignatureDeclaration.h>
+#include <util/helpers.h>
+#include <binder/variable.h>
+#include <binder/scope.h>
+
+#include <typescript/checker.h>
+#include <typescript/types/indexInfo.h>
+
+namespace panda::es2panda::checker {
+
+ObjectLiteralPropertyInfo Checker::HandleObjectLiteralProperty(const ir::Property *prop, ObjectDescriptor *desc,
+                                                               std::vector<Type *> *stringIndexTypes, bool readonly)
+{
+    ObjectLiteralPropertyInfo propInfo;
+    bool computed = prop->IsComputed();
+    bool shorthand = prop->IsShorthand();
+
+    const ir::Expression *propValue = prop->Value();
+    // TODO(aszilagyi): params readonly, readonly
+    propInfo.propType = shorthand ? GlobalAnyType() : propValue->Check(this);
+
+    if (prop->Kind() == ir::PropertyKind::GET) {
+        const ir::ScriptFunction *func = prop->Value()->AsFunctionExpression()->Function();
+        CheckAllCodePathsInNonVoidFunctionReturnOrThrow(func, prop->Start(), "A 'get' accessor must return a value.");
+
+        ASSERT(propInfo.propType->AsObjectType()->IsFunctionType());
+        propInfo.propType = propInfo.propType->AsObjectType()->CallSignatures()[0]->ReturnType();
+    } else if (prop->Kind() == ir::PropertyKind::SET) {
+        ASSERT(propInfo.propType->AsObjectType()->IsFunctionType());
+        propInfo.propType = propInfo.propType->AsObjectType()->CallSignatures()[0]->Params()[0]->TsType();
+    }
+
+    if (!readonly) {
+        propInfo.propType = GetBaseTypeOfLiteralType(propInfo.propType);
+    }
+
+    if (computed) {
+        propInfo.propName = HandleComputedPropertyName(prop->Key(), desc, propInfo.propType, stringIndexTypes,
+                                                       &propInfo.handleNextProp, prop->Start(), readonly);
+
+        if (propInfo.handleNextProp) {
+            return propInfo;
+        }
+    } else {
+        propInfo.propName = ToPropertyName(prop->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME);
+    }
+
+    if (shorthand) {
+        binder::ScopeFindResult result = scope_->Find(propInfo.propName);
+        if (!result.variable) {
+            ThrowTypeError({"No value exists in scope for the shorthand property '", propInfo.propName,
+                            "'. Either declare one ", "or provide an initializer."},
+                           prop->Start());
+        } else {
+            // TODO(aszilagyi): param readonly
+            propInfo.propType = prop->Key()->Check(this);
+        }
+    }
+
+    return propInfo;
+}
+
+void Checker::HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDescriptor *desc,
+                                  lexer::SourcePosition locInfo, bool readonly)
+{
+    // TODO(aszilagyi): handle other types of spread elements, for example ...[a,b,c], or ...{a,b,c}
+    if (!spreadElem->Argument()->IsIdentifier()) {
+        return;
+    }
+
+    Type *spreadType = nullptr;
+    binder::ScopeFindResult result = scope_->Find(spreadElem->Argument()->AsIdentifier()->Name());
+    if (!result.variable) {
+        ThrowTypeError("Cannot find name ", locInfo);
+    }
+
+    spreadType = spreadElem->Argument()->Check(this);
+    if (!spreadType->IsObjectType()) {
+        ThrowTypeError("Spread types may only be created from object types", locInfo);
+    }
+
+    ObjectType *spreadObj = spreadType->AsObjectType();
+    for (auto *it : spreadObj->Properties()) {
+        binder::LocalVariable *res = desc->FindProperty(it->Name());
+        if (res) {
+            if (readonly) {
+                res->AddFlag(binder::VariableFlags::READONLY);
+            }
+            res->SetTsType(it->TsType());
+        } else {
+            auto *var = binder::Scope::CreateVar(allocator_, it->Name(), it->Flags(), nullptr);
+
+            if (readonly) {
+                var->AddFlag(binder::VariableFlags::READONLY);
+            }
+            desc->properties.push_back(var);
+        }
+    }
+
+    if (spreadObj->IsInterfaceType()) {
+        InterfaceType *spreadInterface = spreadObj->AsInterfaceType();
+        for (auto *base : spreadInterface->Bases()) {
+            for (auto *prop : base->Properties()) {
+                binder::LocalVariable *res = desc->FindProperty(prop->Name());
+                if (res) {
+                    res->SetTsType(prop->TsType());
+                } else {
+                    auto *var = binder::Scope::CreateVar(allocator_, prop->Name(), prop->Flags(), nullptr);
+                    desc->properties.push_back(var);
+                }
+            }
+        }
+    }
+}
+
+Type *Checker::CollectStringIndexInfoTypes(const ObjectDescriptor *desc, const std::vector<Type *> &stringIndexTypes)
+{
+    if (stringIndexTypes.empty()) {
+        return nullptr;
+    }
+
+    std::vector<Type *> collectedTypes;
+
+    for (const auto *it : desc->properties) {
+        if (it->TsType()->IsUnionType()) {
+            const auto &constituentTypes = it->TsType()->AsUnionType()->ConstituentTypes();
+            for (auto *type : constituentTypes) {
+                collectedTypes.push_back(type);
+            }
+        } else {
+            collectedTypes.push_back(it->TsType());
+        }
+    }
+
+    for (const auto &it : stringIndexTypes) {
+        if (it->IsUnionType()) {
+            std::vector<Type *> &constituentTypes = it->AsUnionType()->ConstituentTypes();
+            for (auto *type : constituentTypes) {
+                collectedTypes.push_back(type);
+            }
+        } else {
+            collectedTypes.push_back(it);
+        }
+    }
+
+    if (desc->numberIndexInfo) {
+        if (desc->numberIndexInfo->InfoType()->IsUnionType()) {
+            std::vector<Type *> &constituentTypes =
+                desc->numberIndexInfo->InfoType()->AsUnionType()->ConstituentTypes();
+            for (auto *type : constituentTypes) {
+                collectedTypes.push_back(type);
+            }
+        } else {
+            collectedTypes.push_back(desc->numberIndexInfo->InfoType());
+        }
+    }
+
+    if (collectedTypes.empty()) {
+        return nullptr;
+    }
+
+    if (collectedTypes.size() == 1) {
+        return collectedTypes[0];
+    }
+
+    return CreateUnionType(std::move(collectedTypes));
+}
+
+binder::Variable *Checker::ResolveNonComputedObjectProperty(const ir::MemberExpression *expr)
+{
+    const ir::MemberExpression *memberLocation = ResolveLeftMostMemberExpression(expr);
+    Type *baseType = nullptr;
+
+    while (true) {
+        baseType = memberLocation->Object()->Check(this);
+        baseType = ResolveBaseProp(baseType, memberLocation->Property(), false, memberLocation->Start());
+
+        if (!memberLocation->Parent()->IsMemberExpression() ||
+            memberLocation->Parent()->AsMemberExpression()->IsComputed()) {
+            break;
+        }
+
+        memberLocation = memberLocation->Parent()->AsMemberExpression();
+    }
+
+    return baseType->Variable();
+}
+
+binder::Variable *Checker::ResolveObjectProperty(const ir::MemberExpression *expr)
+{
+    const ir::MemberExpression *memberLocation = ResolveLeftMostMemberExpression(expr);
+    Type *baseType = nullptr;
+
+    while (true) {
+        baseType = memberLocation->Object()->Check(this);
+        baseType = ResolveBaseProp(baseType, memberLocation->Property(), memberLocation->IsComputed(),
+                                   memberLocation->Start());
+
+        if (!memberLocation->Parent()->IsMemberExpression()) {
+            break;
+        }
+
+        memberLocation = memberLocation->Parent()->AsMemberExpression();
+    }
+
+    return baseType->Variable();
+}
+
+util::StringView Checker::ToPropertyName(const ir::Expression *expr, TypeFlag propNameFlags, bool computed,
+                                         bool *hasName, Type **exprType)
+{
+    if (computed) {
+        Type *propType = expr->Check(this);
+        if (!propType->HasTypeFlag(propNameFlags)) {
+            ThrowTypeError(
+                "A computed property name in a type literal must refer to an expression whose type is a literal "
+                "type "
+                "or a 'unique symbol' type",
+                expr->Start());
+        }
+
+        if (exprType) {
+            *exprType = propType;
+        }
+
+        if (propType->IsStringLiteralType()) {
+            return propType->AsStringLiteralType()->Value();
+        }
+
+        if (propType->IsNumberLiteralType()) {
+            return util::Helpers::ToStringView(allocator_, propType->AsNumberLiteralType()->Value());
+        }
+
+        if (propType->TypeFlags() == TypeFlag::ENUM) {
+            EnumType *enumType = propType->AsEnumType();
+
+            if (std::holds_alternative<double>(enumType->EnumVar()->Value())) {
+                return util::Helpers::ToStringView(allocator_, std::get<double>(enumType->EnumVar()->Value()));
+            }
+
+            if (std::holds_alternative<util::StringView>(enumType->EnumVar()->Value())) {
+                return std::get<util::StringView>(enumType->EnumVar()->Value());
+            }
+        }
+
+        if (hasName) {
+            *hasName = false;
+        }
+
+        return util::StringView();
+    }
+
+    if (exprType) {
+        *exprType = GlobalStringType();
+    }
+
+    if (expr->IsIdentifier()) {
+        const ir::Identifier *identNode = expr->AsIdentifier();
+        return identNode->Name();
+    }
+
+    switch (expr->Type()) {
+        case ir::AstNodeType::NUMBER_LITERAL: {
+            return util::Helpers::ToStringView(allocator_, expr->AsNumberLiteral()->Number<double>());
+        }
+        case ir::AstNodeType::STRING_LITERAL: {
+            return expr->AsStringLiteral()->Str();
+        }
+        case ir::AstNodeType::BIGINT_LITERAL: {
+            return expr->AsBigIntLiteral()->Str();
+        }
+        default: {
+            break;
+        }
+    }
+
+    UNREACHABLE();
+
+    return util::StringView();
+}
+
+void Checker::PrefetchTypeLiteralProperties(const ir::Expression *current, checker::ObjectDescriptor *desc)
+{
+    ASSERT(current->IsTSPropertySignature() || current->IsTSMethodSignature());
+    util::StringView propName;
+    bool isComputed = false;
+    bool isComputedIdent = false;
+    bool isOptional = false;
+    bool isPropSignature = false;
+    bool isReadonly = false;
+    Type *propNameType = nullptr;
+    const ir::Expression *key = nullptr;
+
+    if (current->IsTSPropertySignature()) {
+        const ir::TSPropertySignature *propSignature = current->AsTSPropertySignature();
+        isOptional = propSignature->Optional();
+        key = propSignature->Key();
+        isComputed = propSignature->Computed();
+        isReadonly = propSignature->Readonly();
+        isPropSignature = true;
+    } else {
+        const ir::TSMethodSignature *methodSignature = current->AsTSMethodSignature();
+        isOptional = methodSignature->Optional();
+        key = methodSignature->Key();
+        isComputed = methodSignature->Computed();
+    }
+
+    if (isComputed) {
+        isComputedIdent = key->IsIdentifier();
+    }
+
+    propName = ToPropertyName(key, TypeFlag::COMPUTED_TYPE_LITERAL_NAME, isComputed, nullptr, &propNameType);
+
+    auto *prop = binder::Scope::CreateVar(allocator_, propName, binder::VariableFlags::NONE, current);
+
+    if (isOptional) {
+        prop->AddFlag(binder::VariableFlags::OPTIONAL);
+    }
+
+    if (isReadonly) {
+        prop->AddFlag(binder::VariableFlags::READONLY);
+    }
+
+    if (propNameType->HasTypeFlag(TypeFlag::NUMBER_LIKE_ENUM)) {
+        prop->AddFlag(binder::VariableFlags::COMPUTED_INDEX);
+    }
+
+    if (key->IsLiteral() && key->AsLiteral()->IsNumberLiteral()) {
+        prop->AddFlag(binder::VariableFlags::INDEX_NAME);
+    }
+
+    if (isComputed) {
+        prop->AddFlag(binder::VariableFlags::COMPUTED);
+    }
+
+    if (isComputedIdent) {
+        prop->AddFlag(binder::VariableFlags::COMPUTED_IDENT);
+    }
+
+    if (isPropSignature) {
+        prop->AddFlag(binder::VariableFlags::PROPERTY);
+    } else {
+        prop->AddFlag(binder::VariableFlags::METHOD);
+    }
+
+    desc->properties.push_back(prop);
+}
+
+void Checker::CheckTsTypeLiteralOrInterfaceMember(const ir::Expression *current, ObjectDescriptor *desc)
+{
+    if (current->IsTSPropertySignature() || (current->IsTSMethodSignature())) {
+        CheckTsPropertyOrMethodSignature(current, desc);
+        return;
+    }
+
+    if (current->IsTSSignatureDeclaration()) {
+        CheckTsSignatureDeclaration(current->AsTSSignatureDeclaration(), desc);
+    } else if (current->IsTSIndexSignature()) {
+        CheckTsIndexSignature(current->AsTSIndexSignature(), desc);
+    }
+}
+
+Type *Checker::CheckIndexInfoProperty(IndexInfo *info, Type *objType, lexer::SourcePosition loc)
+{
+    if (info->Readonly() && !objType->AsObjectType()->IsTupleType()) {
+        ThrowTypeError({"Index signature in type '", objType, "' only permits reading."}, loc);
+    }
+    return info->InfoType();
+}
+
+Type *Checker::ResolveBasePropForObject(ObjectType *objType, util::StringView &name, Type *propNameType,
+                                        bool isComputed, bool inAssignment, lexer::SourcePosition propLoc,
+                                        lexer::SourcePosition exprLoc)
+{
+    binder::LocalVariable *prop = objType->GetProperty(name);
+
+    if (prop) {
+        if (prop && prop->HasFlag(binder::VariableFlags::READONLY) && inAssignment) {
+            ThrowTypeError({"Cannot assign to '", prop->Name(), "' because it is a read-only property."}, propLoc);
+        }
+
+        if (prop->TsType()) {
+            return prop->TsType();
+        }
+
+        const ir::AstNode *declNode = prop->Declaration()->Node();
+        Type *resolvedType = nullptr;
+
+        if (prop->HasFlag(binder::VariableFlags::PROPERTY)) {
+            ASSERT(declNode->IsTSPropertySignature());
+            resolvedType = CheckTsPropertySignature(declNode->AsTSPropertySignature(), prop);
+        }
+
+        if (prop->HasFlag(binder::VariableFlags::METHOD)) {
+            ASSERT(declNode->IsTSMethodSignature());
+            resolvedType = CheckTsMethodSignature(declNode->AsTSMethodSignature());
+        }
+
+        prop->SetTsType(resolvedType);
+        return resolvedType;
+    }
+
+    if (objType->IsTupleType()) {
+        ThrowTypeError({"Tuple type '", objType, "' of length '", objType->AsTupleType()->FixedLength(),
+                        "' has no element at index '", name, "'."},
+                       propLoc);
+    }
+
+    IndexInfo *numberInfo = objType->NumberIndexInfo();
+
+    if (!numberInfo && objType->IsInterfaceType()) {
+        numberInfo = objType->AsInterfaceType()->FindIndexInfo(true);
+    }
+
+    if (numberInfo && propNameType && propNameType->HasTypeFlag(TypeFlag::NUMBER_LIKE)) {
+        return CheckIndexInfoProperty(numberInfo, objType, exprLoc);
+    }
+
+    IndexInfo *stringInfo = objType->StringIndexInfo();
+
+    if (!stringInfo && objType->IsInterfaceType()) {
+        stringInfo = objType->AsInterfaceType()->FindIndexInfo(false);
+    }
+
+    if (stringInfo) {
+        return CheckIndexInfoProperty(stringInfo, objType, exprLoc);
+    }
+
+    if (isComputed) {
+        return GlobalAnyType();
+    }
+
+    ThrowTypeError({"Property '", name, "' does not exist on type '", objType, "'."}, propLoc);
+
+    return nullptr;
+}
+
+Type *Checker::ResolveBaseProp(Type *baseType, const ir::Expression *prop, bool isComputed,
+                               lexer::SourcePosition exprLoc)
+{
+    Type *propNameType = nullptr;
+    bool hasName = true;
+    util::StringView name = ToPropertyName(prop, TypeFlag::COMPUTED_NAME, isComputed, &hasName, &propNameType);
+
+    if (baseType->IsEnumLiteralType()) {
+        EnumLiteralType *enumType = baseType->AsEnumLiteralType();
+
+        if (!hasName) {
+            if (propNameType->HasTypeFlag(TypeFlag::NUMBER_LIKE)) {
+                return GlobalStringType();
+            }
+
+            return GlobalAnyType();
+        }
+
+        binder::Variable *enumVar = enumType->Scope()->FindLocal(name);
+
+        if (enumVar) {
+            if (enumVar->AsEnumVariable()->BackReference()) {
+                ThrowTypeError(
+                    "Element implicitly has an 'any' type because index expression is not of type "
+                    "'number'.",
+                    prop->Start());
+            }
+
+            return allocator_->New<EnumType>(baseType->Variable(), enumVar->AsEnumVariable());
+        }
+    }
+
+    if (baseType->IsObjectType()) {
+        return ResolveBasePropForObject(baseType->AsObjectType(), name, propNameType, isComputed,
+                                        (!prop->Parent()->Parent()->IsMemberExpression() ||
+                                         (baseType->IsObjectType() && baseType->AsObjectType()->IsTupleType())) &&
+                                            InAssignment(prop),
+                                        prop->Start(), exprLoc);
+    }
+
+    if (baseType->IsArrayType()) {
+        return baseType->AsArrayType()->ElementType();
+    }
+
+    if (baseType->IsUnionType()) {
+        std::vector<Type *> types;
+
+        for (auto *it : baseType->AsUnionType()->ConstituentTypes()) {
+            types.push_back(ResolveBaseProp(it, prop, isComputed, exprLoc));
+        }
+
+        return CreateUnionType(std::move(types));
+    }
+
+    ThrowTypeError({"Property '", name, "' does not exist on type '", baseType, "'."}, prop->Start());
+
+    return nullptr;
+}
+
+Type *Checker::CheckTsPropertySignature(const ir::TSPropertySignature *propSignature, binder::LocalVariable *savedProp)
+{
+    if (!propSignature->TypeAnnotation()) {
+        return GlobalAnyType();
+    }
+
+    // TODO(aszilagyi) : saved_prop
+    (void)savedProp;
+    return propSignature->TypeAnnotation()->Check(this);
+}
+
+Type *Checker::CheckTsMethodSignature(const ir::TSMethodSignature *methodSignature)
+{
+    Type *returnType = GlobalAnyType();
+
+    if (methodSignature->ReturnTypeAnnotation()) {
+        returnType = methodSignature->ReturnTypeAnnotation()->Check(this);
+    }
+
+    ScopeContext scopeCtx(this, methodSignature->Scope());
+
+    auto *signatureInfo = allocator_->New<checker::SignatureInfo>();
+    CheckFunctionParameterDeclaration(methodSignature->Params(), signatureInfo);
+
+    auto *callSiganture = allocator_->New<Signature>(signatureInfo, returnType);
+    Type *propType = CreateFunctionTypeWithSignature(callSiganture);
+
+    return propType;
+}
+
+void Checker::CheckTsIndexSignature(const ir::TSIndexSignature *indexSignature, ObjectDescriptor *desc)
+{
+    const util::StringView &paramName = indexSignature->Param()->AsIdentifier()->Name();
+    Type *indexType = indexSignature->TypeAnnotation()->Check(this);
+
+    if (indexSignature->Kind() == ir::TSIndexSignature::TSIndexSignatureKind::NUMBER) {
+        if (desc->numberIndexInfo) {
+            ThrowTypeError("Duplicate number index signature", indexSignature->Start());
+        }
+
+        desc->numberIndexInfo = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
+
+        if (desc->stringIndexInfo) {
+            IsTypeAssignableTo(indexType, desc->stringIndexInfo->InfoType(),
+                               {"Numeric index type '", indexType, "' is not assignable to string index type '",
+                                desc->stringIndexInfo->InfoType(), "'"},
+                               indexSignature->Start());
+        }
+    } else {
+        ASSERT(indexSignature->Kind() == ir::TSIndexSignature::TSIndexSignatureKind::STRING);
+        if (desc->stringIndexInfo) {
+            ThrowTypeError("Duplicate string index signature", indexSignature->Start());
+        }
+
+        desc->stringIndexInfo = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
+
+        if (desc->numberIndexInfo) {
+            IsTypeAssignableTo(desc->numberIndexInfo->InfoType(), indexType,
+                               {"Numeric index type '", desc->numberIndexInfo->InfoType(),
+                                "' is not assignable to string index type '", indexType, "'"},
+                               indexSignature->Start());
+        }
+    }
+}
+
+void Checker::CheckTsSignatureDeclaration(const ir::TSSignatureDeclaration *signatureNode, ObjectDescriptor *desc)
+{
+    ScopeContext scopeCtx(this, signatureNode->Scope());
+
+    auto *signatureInfo = allocator_->New<checker::SignatureInfo>();
+    CheckFunctionParameterDeclaration(signatureNode->Params(), signatureInfo);
+
+    Type *returnType = GlobalAnyType();
+    if (signatureNode->ReturnTypeAnnotation()) {
+        returnType = signatureNode->ReturnTypeAnnotation()->Check(this);
+    }
+
+    auto *signature = allocator_->New<Signature>(signatureInfo, returnType);
+
+    if (signatureNode->Kind() == ir::TSSignatureDeclaration::TSSignatureDeclarationKind::CALL_SIGNATURE) {
+        desc->callSignatures.push_back(signature);
+    } else {
+        desc->constructSignatures.push_back(signature);
+    }
+}
+
+void Checker::CheckTsPropertyOrMethodSignature(const ir::Expression *current, ObjectDescriptor *desc)
+{
+    bool isComputed = false;
+    bool isPropSignature = false;
+    Type *propNameType = nullptr;
+    const ir::Expression *key = nullptr;
+
+    if (current->IsTSPropertySignature()) {
+        const auto *propSignature = current->AsTSPropertySignature();
+        key = propSignature->Key();
+        isComputed = propSignature->Computed();
+        isPropSignature = true;
+    } else {
+        const auto *methodSignature = current->AsTSMethodSignature();
+        key = methodSignature->Key();
+        isComputed = methodSignature->Computed();
+    }
+
+    util::StringView propName =
+        ToPropertyName(key, TypeFlag::COMPUTED_TYPE_LITERAL_NAME, isComputed, nullptr, &propNameType);
+    binder::LocalVariable *prop = desc->FindProperty(propName);
+    ASSERT(prop);
+
+    if (prop->TsType()) {
+        return;
+    }
+
+    Type *propType = nullptr;
+    if (isPropSignature) {
+        propType = CheckTsPropertySignature(current->AsTSPropertySignature(), prop);
+    } else {
+        propType = CheckTsMethodSignature(current->AsTSMethodSignature());
+    }
+
+    propType->SetVariable(prop);
+    prop->SetTsType(propType);
+}
+
+void Checker::HandleNumberIndexInfo(ObjectDescriptor *desc, Type *indexType, bool readonly)
+{
+    if (desc->numberIndexInfo) {
+        if (desc->numberIndexInfo->InfoType()->IsUnionType()) {
+            desc->numberIndexInfo->InfoType()->AsUnionType()->AddConstituentType(indexType, relation_);
+        } else {
+            Type *numIndexType = CreateUnionType({desc->numberIndexInfo->InfoType(), indexType});
+            desc->numberIndexInfo->SetInfoType(numIndexType);
+        }
+    } else {
+        auto *numIndexInfo = allocator_->New<IndexInfo>(indexType, "x", readonly);
+        desc->numberIndexInfo = numIndexInfo;
+    }
+}
+
+util::StringView Checker::HandleComputedPropertyName(const ir::Expression *propKey, ObjectDescriptor *desc,
+                                                     Type *propType, std::vector<Type *> *stringIndexTypes,
+                                                     bool *handleNextProp, lexer::SourcePosition locInfo, bool readonly)
+{
+    util::StringView propName;
+
+    if (propKey->IsIdentifier()) {
+        const ir::Identifier *identKey = propKey->AsIdentifier();
+        binder::ScopeFindResult result = scope_->Find(identKey->Name());
+        if (!result.variable) {
+            ThrowTypeError({"Cannot find name '", identKey->Name(), "'"}, locInfo);
+        }
+
+        Type *computedPropType = identKey->Check(this);
+
+        if (!computedPropType->HasTypeFlag(TypeFlag::COMPUTED_NAME)) {
+            ThrowTypeError("A computed property name must be of type 'string', 'number', 'symbol', or 'any'", locInfo);
+        } else if (computedPropType->HasTypeFlag(TypeFlag::NUMBER_OR_ANY)) {
+            HandleNumberIndexInfo(desc, propType, readonly);
+            *handleNextProp = true;
+        } else if (computedPropType->IsStringType()) {
+            stringIndexTypes->push_back(propType);
+            *handleNextProp = true;
+        } else if (computedPropType->IsNumberLiteralType()) {
+            propName = util::Helpers::ToStringView(allocator_, computedPropType->AsNumberLiteralType()->Value());
+        } else if (computedPropType->IsStringLiteralType()) {
+            propName = computedPropType->AsStringLiteralType()->Value();
+        }
+    } else if (propKey->IsLiteral()) {
+        if (propKey->IsNumberLiteral()) {
+            propName = util::Helpers::ToStringView(allocator_, propKey->AsNumberLiteral()->Number<double>());
+        } else if (propKey->IsStringLiteral()) {
+            propName = propKey->AsStringLiteral()->Str();
+        } else {
+            ThrowTypeError("A computed property name must be of type 'string', 'number', 'symbol', or 'any'", locInfo);
+        }
+    } else {
+        Type *computedKeyType = propKey->Check(this);
+        if (computedKeyType->HasTypeFlag(TypeFlag::NUMBER_LIKE_ENUM)) {
+            HandleNumberIndexInfo(desc, propType, readonly);
+            *handleNextProp = true;
+        } else if (computedKeyType->IsStringType()) {
+            stringIndexTypes->push_back(propType);
+            *handleNextProp = true;
+        } else {
+            ThrowTypeError("A computed property name must be of type 'string', 'number', 'symbol', or 'any'", locInfo);
+        }
+    }
+
+    return propName;
+}
+
+void Checker::CheckIndexConstraints(Type *type) const
+{
+    if (!type->IsObjectType()) {
+        return;
+    }
+
+    ObjectType *objType = type->AsObjectType();
+
+    const IndexInfo *numberInfo = objType->NumberIndexInfo();
+    const IndexInfo *stringInfo = objType->StringIndexInfo();
+    std::vector<binder::LocalVariable *> properties;
+
+    if (objType->IsInterfaceType()) {
+        if (!numberInfo) {
+            numberInfo = objType->AsInterfaceType()->FindIndexInfo(true);
+        }
+        if (!stringInfo) {
+            stringInfo = objType->AsInterfaceType()->FindIndexInfo(false);
+        }
+
+        objType->AsInterfaceType()->CollectProperties(&properties);
+    } else {
+        properties = objType->Properties();
+    }
+
+    if (numberInfo) {
+        for (auto *it : properties) {
+            if (it->HasFlag(binder::VariableFlags::INDEX_LIKE)) {
+                IsTypeAssignableTo(it->TsType(), numberInfo->InfoType(),
+                                   {"Property '", it->Name(), "' of type '", it->TsType(),
+                                    "' is not assignable to numeric index type '", numberInfo->InfoType(), "'."},
+                                   it->Declaration()->Node()->Start());
+            }
+        }
+    }
+
+    if (stringInfo) {
+        for (auto *it : properties) {
+            IsTypeAssignableTo(it->TsType(), stringInfo->InfoType(),
+                               {"Property '", it->Name(), "' of type '", it->TsType(),
+                                "' is not assignable to string index type '", stringInfo->InfoType(), "'."},
+                               it->Declaration()->Node()->Start());
+        }
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/typeCreation.cpp b/es2panda/typescript/core/typeCreation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b3aab4d5f5f584e2d10fc36d8040a49d5d76f42
--- /dev/null
+++ b/es2panda/typescript/core/typeCreation.cpp
@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <typescript/checker.h>
+#include <typescript/types/indexInfo.h>
+
+namespace panda::es2panda::checker {
+
+Type *Checker::CreateNumberLiteralType(double value)
+{
+    auto search = numberLiteralMap_.find(value);
+    if (search != numberLiteralMap_.end()) {
+        return search->second;
+    }
+
+    auto *newNumLiteralType = allocator_->New<NumberLiteralType>(value);
+    numberLiteralMap_.insert({value, newNumLiteralType});
+    return newNumLiteralType;
+}
+
+Type *Checker::CreateBigintLiteralType(const util::StringView &str, bool negative)
+{
+    auto search = bigintLiteralMap_.find(str);
+    if (search != bigintLiteralMap_.end()) {
+        return search->second;
+    }
+
+    auto *newBigiLiteralType = allocator_->New<BigintLiteralType>(str, negative);
+    bigintLiteralMap_.insert({str, newBigiLiteralType});
+    return newBigiLiteralType;
+}
+
+Type *Checker::CreateStringLiteralType(const util::StringView &str)
+{
+    auto search = stringLiteralMap_.find(str);
+    if (search != stringLiteralMap_.end()) {
+        return search->second;
+    }
+
+    auto *newStrLiteralType = allocator_->New<StringLiteralType>(str);
+    stringLiteralMap_.insert({str, newStrLiteralType});
+    return newStrLiteralType;
+}
+
+Type *Checker::CreateUnionType(std::initializer_list<Type *> constituentTypes)
+{
+    std::vector<Type *> newConstituentTypes;
+    for (auto *it : constituentTypes) {
+        newConstituentTypes.push_back(it);
+    }
+
+    return CreateUnionType(std::move(newConstituentTypes));
+}
+
+Type *Checker::CreateUnionType(std::vector<Type *> &&constituentTypes)
+{
+    UnionType::RemoveDuplicatedTypes(relation_, constituentTypes);
+
+    if (constituentTypes.size() == 1) {
+        return constituentTypes[0];
+    }
+
+    auto *newUnionType = allocator_->New<UnionType>(std::move(constituentTypes));
+
+    return UnionType::HandleUnionType(newUnionType, globalTypes_);
+}
+
+Type *Checker::CreateFunctionTypeWithSignature(Signature *callSignature)
+{
+    auto *funcObjType = allocator_->New<FunctionType>(allocator_->New<ObjectDescriptor>());
+    funcObjType->AddSignature(callSignature);
+    return funcObjType;
+}
+
+Type *Checker::CreateConstructorTypeWithSignature(Signature *constructSignature)
+{
+    auto *constructObjType = allocator_->New<ConstructorType>(allocator_->New<ObjectDescriptor>());
+    constructObjType->AddSignature(constructSignature, false);
+    return constructObjType;
+}
+
+Type *Checker::CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                               uint32_t minLength, uint32_t fixedLength, bool readonly)
+{
+    desc->stringIndexInfo = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
+
+    auto *tupleType =
+        allocator_->New<TupleType>(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength, readonly);
+
+    return tupleType;
+}
+
+Type *Checker::CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                               uint32_t minLength, uint32_t fixedLength, bool readonly,
+                               NamedTupleMemberPool &&namedMembers)
+{
+    desc->stringIndexInfo = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
+    ObjectType *tupleType = nullptr;
+
+    if (!namedMembers.empty()) {
+        tupleType = allocator_->New<TupleType>(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength,
+                                               readonly, std::move(namedMembers));
+    } else {
+        tupleType =
+            allocator_->New<TupleType>(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength, readonly);
+    }
+
+    return tupleType;
+}
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/typeElaboration.cpp b/es2panda/typescript/core/typeElaboration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..61cd7c2be45f189b5531ae52e91ed122a68e3dd8
--- /dev/null
+++ b/es2panda/typescript/core/typeElaboration.cpp
@@ -0,0 +1,704 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/statements/variableDeclarator.h>
+#include <ir/base/property.h>
+#include <ir/base/spreadElement.h>
+#include <typescript/checker.h>
+#include <typescript/types/indexInfo.h>
+#include <binder/declaration.h>
+#include <binder/scope.h>
+#include <binder/variable.h>
+
+namespace panda::es2panda::checker {
+
+bool Checker::ElaborateElementwise(TypeOrNode source, const Type *targetType, lexer::SourcePosition locInfo)
+{
+    const ir::AstNode *sourceNode = nullptr;
+    Type *sourceType = nullptr;
+
+    if (std::holds_alternative<const ir::AstNode *>(source)) {
+        sourceNode = std::get<const ir::AstNode *>(source);
+    } else {
+        ASSERT(std::holds_alternative<Type *>(source));
+        sourceType = std::get<Type *>(source);
+    }
+
+    if (((sourceNode && sourceNode->IsArrayExpression()) ||
+         (sourceType && sourceType->IsObjectType() && sourceType->AsObjectType()->IsTupleType())) &&
+        (MaybeTypeOfKind(targetType, TypeFlag::ARRAY) ||
+         MaybeTypeOfKind(targetType, ObjectType::ObjectTypeKind::TUPLE))) {
+        return ElaborateArrayLiteral(source, targetType, locInfo);
+    }
+
+    if (((sourceNode && sourceNode->IsObjectExpression()) ||
+         (sourceType && sourceType->IsObjectType() && sourceType->AsObjectType()->IsObjectLiteralType())) &&
+        (MaybeTypeOfKind(targetType, ObjectType::ObjectTypeKind::LITERAL) ||
+         MaybeTypeOfKind(targetType, ObjectType::ObjectTypeKind::INTERFACE))) {
+        return ElaborateObjectLiteral(source, targetType, locInfo);
+    }
+
+    return false;
+}
+
+bool Checker::ElaborateObjectLiteral(TypeOrNode source, const Type *targetType, lexer::SourcePosition locInfo)
+{
+    const ir::ObjectExpression *sourceNode = nullptr;
+    ObjectLiteralType *sourceType = nullptr;
+
+    if (std::holds_alternative<const ir::AstNode *>(source)) {
+        sourceNode = std::get<const ir::AstNode *>(source)->AsObjectExpression();
+    } else {
+        ASSERT(std::holds_alternative<Type *>(source));
+        sourceType = std::get<Type *>(source)->AsObjectType()->AsObjectLiteralType();
+    }
+
+    bool targetIsUnion = targetType->IsUnionType();
+    if (targetIsUnion) {
+        for (auto *it : targetType->AsUnionType()->ConstituentTypes()) {
+            if (it->IsObjectType() &&
+                (it->AsObjectType()->IsObjectLiteralType() || it->AsObjectType()->IsInterfaceType()) &&
+                it->GetTypeFacts() == TypeFacts::EMPTY_OBJECT_FACTS) {
+                return true;
+            }
+        }
+    } else if (sourceNode && targetType->GetTypeFacts() == TypeFacts::EMPTY_OBJECT_FACTS) {
+        return true;
+    }
+
+    ObjectLiteralElaborationData elaborationData;
+    elaborationData.desc = allocator_->New<ObjectDescriptor>();
+    GetPotentialTypesAndIndexInfosForElaboration(targetType, &elaborationData);
+
+    if (sourceNode) {
+        bool excessCheckNeeded = ElaborateObjectLiteralWithNode(sourceNode, targetType, &elaborationData);
+        if (!excessCheckNeeded) {
+            excessCheckNeeded = CheckIfExcessTypeCheckNeededForObjectElaboration(targetType, &elaborationData);
+        }
+
+        if (excessCheckNeeded) {
+            for (const auto *it : elaborationData.spreads) {
+                HandleSpreadElement(it->AsSpreadElement(), elaborationData.desc, it->Start());
+            }
+
+            Type *sourceObjType = allocator_->New<ObjectLiteralType>(elaborationData.desc);
+
+            IsTypeAssignableTo(sourceObjType, targetType,
+                               {"Type '", sourceObjType, "' is not assignable to type '", targetType, "'."}, locInfo);
+        }
+
+        return true;
+    }
+
+    ASSERT(sourceType);
+    ElaborateObjectLiteralWithType(sourceType, targetType, elaborationData.potentialObjectTypes, locInfo);
+
+    return true;
+}
+
+void Checker::GetPotentialTypesAndIndexInfosForElaboration(const Type *targetType,
+                                                           ObjectLiteralElaborationData *elaborationData)
+{
+    if (targetType->IsUnionType()) {
+        std::vector<Type *> numberInfoTypes;
+        std::vector<Type *> stringInfoTypes;
+
+        for (auto *it : targetType->AsUnionType()->ConstituentTypes()) {
+            if (it->IsObjectType() &&
+                (it->AsObjectType()->IsObjectLiteralType() || it->AsObjectType()->IsInterfaceType())) {
+                IndexInfoTypePair infoTypePair = GetIndexInfoTypePair(it->AsObjectType());
+                if (infoTypePair.first) {
+                    stringInfoTypes.push_back(infoTypePair.first);
+                }
+
+                if (infoTypePair.second) {
+                    numberInfoTypes.push_back(infoTypePair.second);
+                }
+
+                elaborationData->potentialObjectTypes.insert({it->Id(), it->AsObjectType()});
+            }
+        }
+
+        Type *numberInfosType = nullptr;
+        if (!numberInfoTypes.empty()) {
+            numberInfosType = CreateUnionType(std::move(numberInfoTypes));
+        }
+
+        Type *stringInfosType = nullptr;
+        if (!stringInfoTypes.empty()) {
+            stringInfosType = CreateUnionType(std::move(stringInfoTypes));
+        }
+
+        elaborationData->numberInfosType = numberInfosType;
+        elaborationData->stringInfosType = stringInfosType;
+    } else {
+        IndexInfoTypePair infoTypePair = GetIndexInfoTypePair(targetType->AsObjectType());
+
+        elaborationData->stringInfosType = infoTypePair.first;
+        elaborationData->numberInfosType = infoTypePair.second;
+    }
+}
+
+IndexInfoTypePair Checker::GetIndexInfoTypePair(const ObjectType *type)
+{
+    const IndexInfo *stringIndexInfo = type->StringIndexInfo();
+    const IndexInfo *numberIndexInfo = type->NumberIndexInfo();
+
+    if (type->IsInterfaceType()) {
+        if (!stringIndexInfo) {
+            stringIndexInfo = type->AsInterfaceType()->FindIndexInfo(false);
+        }
+
+        if (!numberIndexInfo) {
+            numberIndexInfo = type->AsInterfaceType()->FindIndexInfo(true);
+        }
+    }
+
+    return {stringIndexInfo ? const_cast<Type *>(stringIndexInfo->InfoType()) : nullptr,
+            numberIndexInfo ? const_cast<Type *>(numberIndexInfo->InfoType()) : nullptr};
+}
+
+bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targetType,
+                                                               ObjectLiteralElaborationData *elaborationData)
+{
+    if (targetType->IsUnionType()) {
+        for (auto it : elaborationData->potentialObjectTypes) {
+            if (!it.second->CallSignatures().empty() || !it.second->ConstructSignatures().empty()) {
+                return true;
+            }
+        }
+    } else if (!targetType->AsObjectType()->CallSignatures().empty() ||
+               !targetType->AsObjectType()->ConstructSignatures().empty()) {
+        return true;
+    }
+
+    if (targetType->IsUnionType()) {
+        uint32_t targetPropCount = 0;
+
+        for (auto it : elaborationData->potentialObjectTypes) {
+            targetPropCount = it.second->Properties().size();
+
+            if (it.second->IsInterfaceType()) {
+                std::vector<binder::LocalVariable *> interfaceProperties;
+                it.second->AsInterfaceType()->CollectProperties(&interfaceProperties);
+                targetPropCount += interfaceProperties.size();
+            }
+
+            if (elaborationData->desc->properties.size() < targetPropCount) {
+                return true;
+            }
+        }
+    } else {
+        uint32_t targetPropCount = targetType->AsObjectType()->Properties().size();
+
+        if (targetType->AsObjectType()->IsInterfaceType()) {
+            std::vector<binder::LocalVariable *> interfaceProperties;
+            targetType->AsObjectType()->AsInterfaceType()->CollectProperties(&interfaceProperties);
+            targetPropCount += interfaceProperties.size();
+        }
+
+        if (elaborationData->desc->properties.size() < targetPropCount) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool Checker::ElaborateObjectLiteralWithNode(const ir::ObjectExpression *sourceNode, const Type *targetType,
+                                             ObjectLiteralElaborationData *elaborationData)
+{
+    bool excessCheckNeeded = false;
+
+    for (auto *sourceProp : sourceNode->Properties()) {
+        if (!sourceProp->IsProperty()) {
+            ASSERT(sourceProp->IsSpreadElement());
+            elaborationData->spreads.push_back(sourceProp->AsSpreadElement());
+            excessCheckNeeded = true;
+            continue;
+        }
+        const ir::Property *currentProp = sourceProp->AsProperty();
+
+        ObjectLiteralPropertyInfo propInfo =
+            HandleObjectLiteralProperty(currentProp, elaborationData->desc, &elaborationData->stringIndexTypes);
+        if (propInfo.handleNextProp) {
+            excessCheckNeeded = true;
+            continue;
+        }
+
+        bool numberLiteralName = currentProp->Key()->IsNumberLiteral();
+
+        Type *targetPropType = GetTargetPropertyTypeFromTargetForElaborationWithNode(
+            targetType, elaborationData, propInfo.propName, currentProp->Value());
+
+        if (!targetPropType) {
+            targetPropType =
+                GetindexInfoTypeOrThrowError(targetType, elaborationData, propInfo.propName, currentProp->IsComputed(),
+                                             numberLiteralName, sourceProp->Start());
+        }
+
+        if (!IsLiteralType(targetPropType) || targetPropType->IsBooleanType()) {
+            propInfo.propType = GetBaseTypeOfLiteralType(propInfo.propType);
+        }
+
+        if (!ElaborateElementwise(currentProp->Value(), targetPropType, sourceProp->Start()) &&
+            !IsTypeAssignableTo(propInfo.propType, targetPropType)) {
+            if (currentProp->IsComputed() && currentProp->Key()->IsIdentifier()) {
+                ThrowTypeError({"Type of computed property's value is '", propInfo.propType,
+                                "', which is not assignable to type '", targetPropType, "'."},
+                               sourceProp->Start());
+            } else {
+                ThrowTypeError({"Type '", propInfo.propType, "' is not assignable to type '", targetPropType, "'."},
+                               sourceProp->Start());
+            }
+        }
+
+        auto *objLitProp =
+            binder::Scope::CreateVar(allocator_, propInfo.propName, binder::VariableFlags::NONE, currentProp);
+
+        objLitProp->AddFlag(currentProp->IsMethod() ? binder::VariableFlags::METHOD : binder::VariableFlags::PROPERTY);
+        propInfo.propType->SetVariable(objLitProp);
+        propInfo.propType->AddTypeFlag(TypeFlag::RELATION_CHECKED);
+        objLitProp->SetTsType(propInfo.propType);
+        elaborationData->desc->properties.push_back(objLitProp);
+    }
+
+    return excessCheckNeeded;
+}
+
+Type *Checker::GetindexInfoTypeOrThrowError(const Type *targetType, ObjectLiteralElaborationData *elaborationData,
+                                            const util::StringView &propName, bool computed, bool numberLiteralName,
+                                            lexer::SourcePosition locInfo)
+{
+    if ((!elaborationData->stringInfosType && !elaborationData->numberInfosType) ||
+        (!numberLiteralName && !elaborationData->stringInfosType)) {
+        std::stringstream ss;
+        if (computed) {
+            ss << "[" << propName << "]";
+        } else {
+            ss << propName;
+        }
+
+        std::string str = ss.str();
+
+        ThrowTypeError({"Object literal may only specify known properties, and '",
+                        util::StringView(std::string_view(str)), "' does not exist in type '", targetType, "'"},
+                       locInfo);
+    }
+
+    if (numberLiteralName && elaborationData->numberInfosType) {
+        return elaborationData->numberInfosType;
+    }
+
+    return elaborationData->stringInfosType;
+}
+
+void Checker::ElaborateObjectLiteralWithType(const ObjectLiteralType *sourceType, const Type *targetType,
+                                             const std::unordered_map<uint32_t, ObjectType *> &potentialObjectTypes,
+                                             [[maybe_unused]] lexer::SourcePosition locInfo)
+{
+    for (auto *sourceProp : sourceType->Properties()) {
+        Type *targetPropType =
+            GetTargetPropertyTypeFromTargetForElaborationWithType(targetType, potentialObjectTypes, sourceProp->Name());
+
+        if (!targetPropType) {
+            // TODO(aszilagyi): search for index info and then throw error if its missing
+            ThrowTypeError({"Property '", sourceProp->Name(), "' does not exist on type '", targetType, "'"},
+                           sourceProp->Declaration()->Node()->Start());
+        }
+
+        Type *sourcePropType = sourceProp->TsType();
+
+        if (!ElaborateElementwise(sourcePropType, targetPropType, sourceProp->Declaration()->Node()->Start()) &&
+            !IsTypeAssignableTo(sourcePropType, targetPropType)) {
+            ThrowTypeError({"Type '", sourcePropType, "' is not assignable to type '", targetPropType, "'."},
+                           sourceProp->Declaration()->Node()->Start());
+        }
+    }
+}
+
+Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type *targetType,
+                                                                     ObjectLiteralElaborationData *elaborationData,
+                                                                     const util::StringView &propName,
+                                                                     const ir::Expression *propValue)
+{
+    binder::LocalVariable *searchProp = nullptr;
+
+    if (targetType->IsUnionType()) {
+        std::vector<Type *> targetPropTypes;
+        for (auto potentialType = elaborationData->potentialObjectTypes.begin();
+             potentialType != elaborationData->potentialObjectTypes.end();) {
+            searchProp = potentialType->second->GetProperty(propName);
+            if (searchProp) {
+                if (searchProp->TsType()->IsUnionType()) {
+                    for (auto *type : searchProp->TsType()->AsUnionType()->ConstituentTypes()) {
+                        targetPropTypes.push_back(type);
+                    }
+                } else {
+                    targetPropTypes.push_back(searchProp->TsType());
+                }
+
+                if (!IsTypeAssignableTo(CreateTupleTypeFromEveryArrayExpression(propValue), searchProp->TsType())) {
+                    potentialType = elaborationData->potentialObjectTypes.erase(potentialType);
+                    continue;
+                }
+
+                potentialType++;
+                continue;
+            }
+
+            potentialType = elaborationData->potentialObjectTypes.erase(potentialType);
+        }
+
+        if (targetPropTypes.empty()) {
+            return nullptr;
+        }
+
+        return CreateUnionType(std::move(targetPropTypes));
+    }
+
+    ASSERT(targetType->IsObjectType());
+    searchProp = targetType->AsObjectType()->GetProperty(propName);
+    if (!searchProp) {
+        return nullptr;
+    }
+
+    return searchProp->TsType();
+}
+
+Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithType(
+    const Type *targetType, const std::unordered_map<uint32_t, ObjectType *> &potentialObjectTypes,
+    const util::StringView &propName)
+{
+    binder::LocalVariable *searchProp = nullptr;
+
+    if (targetType->IsUnionType()) {
+        std::vector<Type *> targetPropTypes;
+        for (auto it : potentialObjectTypes) {
+            searchProp = it.second->GetProperty(propName);
+            if (searchProp) {
+                if (searchProp->TsType()->IsUnionType()) {
+                    for (auto *type : searchProp->TsType()->AsUnionType()->ConstituentTypes()) {
+                        targetPropTypes.push_back(type);
+                    }
+                } else {
+                    targetPropTypes.push_back(searchProp->TsType());
+                }
+            }
+        }
+
+        if (targetPropTypes.empty()) {
+            return nullptr;
+        }
+
+        return CreateUnionType(std::move(targetPropTypes));
+    }
+
+    ASSERT(targetType->IsObjectType());
+    searchProp = targetType->AsObjectType()->GetProperty(propName);
+    if (!searchProp) {
+        return nullptr;
+    }
+
+    return searchProp->TsType();
+}
+
+bool Checker::ElaborateArrayLiteral(TypeOrNode source, const Type *targetType, lexer::SourcePosition locInfo)
+{
+    const ir::ArrayExpression *sourceNode = nullptr;
+    TupleType *sourceType = nullptr;
+
+    if (std::holds_alternative<const ir::AstNode *>(source)) {
+        sourceNode = std::get<const ir::AstNode *>(source)->AsArrayExpression();
+    } else {
+        ASSERT(std::holds_alternative<Type *>(source));
+        sourceType = std::get<Type *>(source)->AsObjectType()->AsTupleType();
+    }
+
+    std::unordered_map<uint32_t, Type *> potentialTypes;
+
+    if (targetType->IsUnionType()) {
+        for (auto *it : targetType->AsUnionType()->ConstituentTypes()) {
+            if (it->IsArrayType() || (it->IsObjectType() && it->AsObjectType()->IsTupleType())) {
+                potentialTypes.insert({it->Id(), it});
+            }
+        }
+    }
+
+    if (sourceNode) {
+        ElaborateArrayLiteralWithNode(sourceNode, targetType, &potentialTypes, locInfo);
+    } else {
+        ASSERT(sourceType);
+        ElaborateArrayLiteralWithType(sourceType, targetType, potentialTypes);
+    }
+
+    if (sourceNode) {
+        CheckTargetTupleLengthConstraints(targetType, sourceNode, &potentialTypes, locInfo);
+    }
+
+    return true;
+}
+
+void Checker::ElaborateArrayLiteralWithNode(const ir::ArrayExpression *sourceNode, const Type *targetType,
+                                            std::unordered_map<uint32_t, Type *> *potentialTypes,
+                                            lexer::SourcePosition locInfo)
+{
+    uint32_t tupleIdx = 0;
+    for (auto *it : sourceNode->Elements()) {
+        Type *currentElementType = it->Check(this);
+        const Type *targetElementType = nullptr;
+
+        if (targetType->IsUnionType()) {
+            std::vector<Type *> newElementUnion =
+                CollectTargetTypesForArrayElaborationWithNodeFromTargetUnion(potentialTypes, it, tupleIdx);
+            if (newElementUnion.empty()) {
+                ThrowTypeError({"Type '", sourceNode->Check(this), "' is not assignable to type '", targetType, "'."},
+                               locInfo);
+            }
+
+            targetElementType = CreateUnionType(std::move(newElementUnion));
+        } else if (targetType->IsObjectType() && targetType->AsObjectType()->IsTupleType()) {
+            const TupleType *targetTuple = targetType->AsObjectType()->AsTupleType();
+
+            if (targetTuple->FixedLength() <= tupleIdx) {
+                ThrowTypeError({"Type '", sourceNode->Check(this), "' is not assignable to type '", targetTuple, "'."},
+                               locInfo);
+            }
+
+            targetElementType = targetTuple->Properties()[tupleIdx]->TsType();
+        } else {
+            ASSERT(targetType->IsArrayType());
+            targetElementType = targetType->AsArrayType()->ElementType();
+        }
+
+        tupleIdx++;
+
+        if (!ElaborateElementwise(it, targetElementType, it->Start()) &&
+            !IsTypeAssignableTo(currentElementType, targetElementType)) {
+            if (targetElementType->HasTypeFlag(TypeFlag::LITERAL)) {
+                ThrowTypeError({"Type '", currentElementType, "' is not assignable to type '", targetElementType, "'."},
+                               it->Start());
+            } else {
+                ThrowTypeError(
+                    {"Type '", AsSrc(currentElementType), "' is not assignable to type '", targetElementType, "'."},
+                    it->Start());
+            }
+        }
+    }
+}
+
+void Checker::ElaborateArrayLiteralWithType(const TupleType *sourceType, const Type *targetType,
+                                            const std::unordered_map<uint32_t, Type *> &potentialTypes)
+{
+    for (size_t tupleIdx = 0; tupleIdx < sourceType->Properties().size(); tupleIdx++) {
+        binder::Variable *sourceProp = sourceType->Properties()[tupleIdx];
+        Type *sourceElementType = sourceProp->TsType();
+        const Type *targetElementType = nullptr;
+
+        if (tupleIdx == sourceType->Properties().size() - 1 && (sourceType->CombinedFlags() & ElementFlags::REST)) {
+            return;
+        }
+
+        if (targetType->IsUnionType()) {
+            std::vector<Type *> newElementUnion =
+                CollectTargetTypesForArrayElaborationWithTypeFromTargetUnion(potentialTypes, tupleIdx);
+            if (newElementUnion.empty()) {
+                ThrowTypeError({"Property '", tupleIdx, "' does not exist on type '", targetType},
+                               sourceProp->Declaration()->Node()->Start());
+            }
+
+            targetElementType = CreateUnionType(std::move(newElementUnion));
+        } else if (targetType->IsObjectType() && targetType->AsObjectType()->IsTupleType()) {
+            const TupleType *targetTuple = targetType->AsObjectType()->AsTupleType();
+
+            if (tupleIdx >= targetTuple->FixedLength()) {
+                ThrowTypeError({"Tuple type '", targetType, "' of length '", targetTuple->FixedLength(),
+                                "' has no element at index '", tupleIdx, "' ."},
+                               sourceProp->Declaration()->Node()->Start());
+            }
+
+            targetElementType = targetTuple->Properties()[tupleIdx]->TsType();
+        } else {
+            ASSERT(targetType->IsArrayType());
+            targetElementType = targetType->AsArrayType()->ElementType();
+        }
+
+        if (!ElaborateElementwise(sourceElementType, targetElementType, sourceProp->Declaration()->Node()->Start()) &&
+            !IsTypeAssignableTo(sourceElementType, targetElementType)) {
+            ThrowTypeError({"Type '", sourceElementType, "' is not assignable to type '", targetElementType, "'."},
+                           sourceProp->Declaration()->Node()->Start());
+        }
+    }
+}
+
+std::vector<Type *> Checker::CollectTargetTypesForArrayElaborationWithNodeFromTargetUnion(
+    std::unordered_map<uint32_t, Type *> *potentialTypes, const ir::Expression *currentSourceElement, uint32_t tupleIdx)
+{
+    std::vector<Type *> newElementUnion;
+
+    for (auto potentialType = potentialTypes->begin(); potentialType != potentialTypes->end();) {
+        if (potentialType->second->IsObjectType() && potentialType->second->AsObjectType()->IsTupleType()) {
+            TupleType *currentTargetTuple = potentialType->second->AsObjectType()->AsTupleType();
+
+            if (currentTargetTuple->FixedLength() <= tupleIdx) {
+                potentialType = potentialTypes->erase(potentialType);
+                continue;
+            }
+
+            Type *elementType = currentTargetTuple->Properties()[tupleIdx]->TsType();
+
+            if (elementType->IsUnionType()) {
+                std::vector<Type *> &types = elementType->AsUnionType()->ConstituentTypes();
+                newElementUnion.insert(newElementUnion.end(), types.begin(), types.end());
+            } else {
+                newElementUnion.push_back(elementType);
+            }
+
+            if (!IsTypeAssignableTo(CreateTupleTypeFromEveryArrayExpression(currentSourceElement), elementType)) {
+                potentialType = potentialTypes->erase(potentialType);
+                continue;
+            }
+        } else if (potentialType->second->IsArrayType()) {
+            Type *potentialArrayElementType = potentialType->second->AsArrayType()->ElementType();
+
+            if (potentialArrayElementType->IsUnionType()) {
+                std::vector<Type *> &types = potentialArrayElementType->AsUnionType()->ConstituentTypes();
+                newElementUnion.insert(newElementUnion.end(), types.begin(), types.end());
+            } else {
+                newElementUnion.push_back(potentialArrayElementType);
+            }
+        }
+
+        potentialType++;
+    }
+
+    return newElementUnion;
+}
+
+std::vector<Type *> Checker::CollectTargetTypesForArrayElaborationWithTypeFromTargetUnion(
+    const std::unordered_map<uint32_t, Type *> &potentialTypes, uint32_t tupleIdx)
+{
+    std::vector<Type *> newElementUnion;
+
+    for (const auto &potentialType : potentialTypes) {
+        if (potentialType.second->IsObjectType() && potentialType.second->AsObjectType()->IsTupleType()) {
+            TupleType *currentTargetTuple = potentialType.second->AsObjectType()->AsTupleType();
+
+            if (currentTargetTuple->FixedLength() <= tupleIdx) {
+                continue;
+            }
+
+            Type *elementType = currentTargetTuple->Properties()[tupleIdx]->TsType();
+
+            if (elementType->IsUnionType()) {
+                std::vector<Type *> &types = elementType->AsUnionType()->ConstituentTypes();
+                newElementUnion.insert(newElementUnion.end(), types.begin(), types.end());
+            } else {
+                newElementUnion.push_back(elementType);
+            }
+        } else if (potentialType.second->IsArrayType()) {
+            Type *potentialArrayElementType = potentialType.second->AsArrayType()->ElementType();
+
+            if (potentialArrayElementType->IsUnionType()) {
+                std::vector<Type *> &types = potentialArrayElementType->AsUnionType()->ConstituentTypes();
+                newElementUnion.insert(newElementUnion.end(), types.begin(), types.end());
+            } else {
+                newElementUnion.push_back(potentialArrayElementType);
+            }
+        }
+    }
+
+    return newElementUnion;
+}
+
+void Checker::CheckTargetTupleLengthConstraints(const Type *targetType, const ir::ArrayExpression *sourceNode,
+                                                std::unordered_map<uint32_t, Type *> *potentialTypes,
+                                                const lexer::SourcePosition &locInfo)
+{
+    if (targetType->IsUnionType()) {
+        for (auto it = potentialTypes->begin(); it != potentialTypes->end();) {
+            if (it->second->IsObjectType() && it->second->AsObjectType()->IsTupleType()) {
+                TupleType *currentTargetTuple = it->second->AsObjectType()->AsTupleType();
+
+                if (currentTargetTuple->MinLength() > sourceNode->Elements().size() ||
+                    (sourceNode->Elements().empty() && currentTargetTuple->MinLength() > 0)) {
+                    it = potentialTypes->erase(it);
+                    continue;
+                }
+            }
+
+            it++;
+        }
+
+        if (potentialTypes->empty()) {
+            ThrowTypeError({"Type '", sourceNode->Check(this), "' is not assignable to type '", targetType, "'."},
+                           locInfo);
+        }
+    } else if (targetType->IsObjectType() && targetType->AsObjectType()->IsTupleType()) {
+        const TupleType *targetTuple = targetType->AsObjectType()->AsTupleType();
+
+        if ((targetTuple->MinLength() > sourceNode->Elements().size()) ||
+            (sourceNode->Elements().empty() && targetTuple->MinLength() > 0)) {
+            ThrowTypeError({"Type '", sourceNode->Check(this), "' is not assignable to type '", targetTuple, "'."},
+                           locInfo);
+        }
+    }
+}
+
+Type *Checker::GetUnaryResultType(Type *operandType)
+{
+    if (MaybeTypeOfKind(operandType, TypeFlag::BIGINT_LIKE)) {
+        if (operandType->HasTypeFlag(TypeFlag::UNION_OR_INTERSECTION) &&
+            MaybeTypeOfKind(operandType, TypeFlag::NUMBER_LIKE)) {
+            return GlobalNumberOrBigintType();
+        }
+
+        return GlobalBigintType();
+    }
+
+    return GlobalNumberType();
+}
+
+Type *Checker::InferVariableDeclarationType(const ir::Identifier *decl)
+{
+    if (!typeStack_.insert(decl).second) {
+        if (decl->TypeAnnotation()) {
+            ThrowTypeError({"'", decl->Name(),
+                            "' is referenced directly or indirectly in its "
+                            "own type annotation."},
+                           decl->Start());
+        }
+
+        ThrowTypeError({"'", decl->Name(),
+                        "' is referenced directly or indirectly in its "
+                        "own initializer."},
+                       decl->Start());
+    }
+
+    Type *inferedType = nullptr;
+    if (decl->TypeAnnotation()) {
+        inferedType = decl->TypeAnnotation()->Check(this);
+    } else if (decl->Parent()->AsVariableDeclarator()->Init()) {
+        inferedType = decl->Parent()->AsVariableDeclarator()->Init()->Check(this);
+    }
+
+    TypeStack().erase(decl);
+    return inferedType;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/typeRelation.cpp b/es2panda/typescript/core/typeRelation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22363fdf3b3407bf4db6c292f1a96ef4e8afdffb
--- /dev/null
+++ b/es2panda/typescript/core/typeRelation.cpp
@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <typescript/checker.h>
+
+#include <algorithm>
+
+namespace panda::es2panda::checker {
+
+bool Checker::IsAllTypesAssignableTo(Type *source, Type *target)
+{
+    if (source->TypeFlags() == TypeFlag::UNION) {
+        auto &types = source->AsUnionType()->ConstituentTypes();
+
+        return std::all_of(types.begin(), types.end(),
+                           [this, target](auto *it) { return IsAllTypesAssignableTo(it, target); });
+    }
+
+    return relation_->IsAssignableTo(source, target);
+}
+
+bool Checker::IsTypeIdenticalTo(const Type *source, const Type *target) const
+{
+    return relation_->IsIdenticalTo(source, target);
+}
+
+bool Checker::IsTypeIdenticalTo(const Type *source, const Type *target, const std::string &errMsg,
+                                const lexer::SourcePosition &errPos) const
+{
+    if (!IsTypeIdenticalTo(source, target)) {
+        relation_->RaiseError(errMsg, errPos);
+    }
+
+    return true;
+}
+
+bool Checker::IsTypeIdenticalTo(const Type *source, const Type *target,
+                                std::initializer_list<TypeErrorMessageElement> list,
+                                const lexer::SourcePosition &errPos) const
+{
+    if (!IsTypeIdenticalTo(source, target)) {
+        relation_->RaiseError(list, errPos);
+    }
+
+    return true;
+}
+
+bool Checker::IsTypeAssignableTo(const Type *source, const Type *target) const
+{
+    return relation_->IsAssignableTo(source, target);
+}
+
+bool Checker::IsTypeAssignableTo(const Type *source, const Type *target, const std::string &errMsg,
+                                 const lexer::SourcePosition &errPos) const
+{
+    if (!IsTypeAssignableTo(source, target)) {
+        relation_->RaiseError(errMsg, errPos);
+    }
+
+    return true;
+}
+
+bool Checker::IsTypeAssignableTo(const Type *source, const Type *target,
+                                 std::initializer_list<TypeErrorMessageElement> list,
+                                 const lexer::SourcePosition &errPos) const
+{
+    if (!IsTypeAssignableTo(source, target)) {
+        relation_->RaiseError(list, errPos);
+    }
+
+    return true;
+}
+
+bool Checker::IsTypeComparableTo(const Type *source, const Type *target) const
+{
+    return relation_->IsComparableTo(source, target);
+}
+
+bool Checker::IsTypeComparableTo(const Type *source, const Type *target, const std::string &errMsg,
+                                 const lexer::SourcePosition &errPos) const
+{
+    if (!IsTypeComparableTo(source, target)) {
+        relation_->RaiseError(errMsg, errPos);
+    }
+
+    return true;
+}
+
+bool Checker::IsTypeComparableTo(const Type *source, const Type *target,
+                                 std::initializer_list<TypeErrorMessageElement> list,
+                                 const lexer::SourcePosition &errPos) const
+{
+    if (!IsTypeComparableTo(source, target)) {
+        relation_->RaiseError(list, errPos);
+    }
+
+    return true;
+}
+
+bool Checker::AreTypesComparable(const Type *source, const Type *target) const
+{
+    return IsTypeComparableTo(source, target) || IsTypeComparableTo(target, source);
+}
+
+bool Checker::IsTypeEqualityComparableTo(const Type *source, const Type *target) const
+{
+    return target->HasTypeFlag(TypeFlag::NULLABLE) || IsTypeComparableTo(source, target);
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/core/util.cpp b/es2panda/typescript/core/util.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..155db3b9ef463a8867ddcad9982496ad8e8b15c4
--- /dev/null
+++ b/es2panda/typescript/core/util.cpp
@@ -0,0 +1,227 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/binaryExpression.h>
+#include <ir/expressions/memberExpression.h>
+#include <ir/expressions/templateLiteral.h>
+
+#include <typescript/checker.h>
+
+namespace panda::es2panda::checker {
+
+bool Checker::InAssignment(const ir::AstNode *node)
+{
+    const ir::AstNode *parent = node;
+
+    while (parent->Parent()) {
+        if (parent->Parent()->IsAssignmentExpression()) {
+            return parent->Parent()->AsAssignmentExpression()->Left() == parent;
+        }
+
+        if (parent->Parent()->IsBinaryExpression()) {
+            const ir::BinaryExpression *binaryExpr = parent->Parent()->AsBinaryExpression();
+            return IsAssignmentOperator(binaryExpr->OperatorType()) && binaryExpr->Left() == parent;
+        }
+
+        if (parent->Parent()->IsUpdateExpression()) {
+            return true;
+        }
+
+        parent = parent->Parent();
+    }
+    return false;
+}
+
+bool Checker::IsAssignmentOperator(lexer::TokenType op)
+{
+    switch (op) {
+        case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MULTIPLY_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MOD_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_MINUS_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_PLUS_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_SUBSTITUTION:
+            return true;
+        default:
+            return false;
+    }
+}
+
+Type *Checker::GetBaseTypeOfLiteralType(Type *type)
+{
+    if (type->IsStringLiteralType()) {
+        return GlobalStringType();
+    }
+
+    if (type->IsNumberLiteralType()) {
+        return GlobalNumberType();
+    }
+
+    if (type->IsBooleanLiteralType()) {
+        return GlobalBooleanType();
+    }
+
+    if (type->IsBigintLiteralType()) {
+        return GlobalBigintType();
+    }
+
+    if (type->IsUnionType()) {
+        std::vector<Type *> &constituentTypes = type->AsUnionType()->ConstituentTypes();
+        std::vector<Type *> newConstituentTypes;
+
+        newConstituentTypes.reserve(constituentTypes.size());
+        for (auto *it : constituentTypes) {
+            newConstituentTypes.push_back(GetBaseTypeOfLiteralType(it));
+        }
+
+        return CreateUnionType(std::move(newConstituentTypes));
+    }
+
+    return type;
+}
+
+bool Checker::IsLiteralType(const Type *type)
+{
+    if (type->IsBooleanType()) {
+        return true;
+    }
+
+    if (type->IsUnionType()) {
+        std::vector<Type *> constituentTypes = type->AsUnionType()->ConstituentTypes();
+        bool result = true;
+        for (auto *it : constituentTypes) {
+            result &= it->HasTypeFlag(TypeFlag::UNIT);
+        }
+        return result;
+    }
+
+    return type->HasTypeFlag(TypeFlag::UNIT);
+}
+
+const ir::AstNode *Checker::FindAncestorGivenByType(const ir::AstNode *node, ir::AstNodeType type)
+{
+    node = node->Parent();
+
+    while (node->Type() != type) {
+        if (node->Parent()) {
+            node = node->Parent();
+            continue;
+        }
+
+        return nullptr;
+    }
+
+    return node;
+}
+
+void Checker::CheckNonNullType(Type *type, lexer::SourcePosition lineInfo)
+{
+    if (type->IsNullType()) {
+        ThrowTypeError("Object is possibly 'null'.", lineInfo);
+    }
+
+    if (type->IsUndefinedType()) {
+        ThrowTypeError("Object is possibly 'undefined'.", lineInfo);
+    }
+}
+
+bool Checker::MaybeTypeOfKind(const Type *type, TypeFlag flags)
+{
+    if (type->HasTypeFlag(flags)) {
+        return true;
+    }
+
+    if (type->HasTypeFlag(TypeFlag::UNION_OR_INTERSECTION)) {
+        if (type->IsUnionType()) {
+            const std::vector<Type *> &constituentTypes = type->AsUnionType()->ConstituentTypes();
+            for (auto *it : constituentTypes) {
+                if (MaybeTypeOfKind(it, flags)) {
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+bool Checker::MaybeTypeOfKind(const Type *type, ObjectType::ObjectTypeKind kind)
+{
+    if (type->IsObjectType() && type->AsObjectType()->Kind() == kind) {
+        return true;
+    }
+
+    if (type->HasTypeFlag(TypeFlag::UNION_OR_INTERSECTION)) {
+        if (type->IsUnionType()) {
+            const std::vector<Type *> &constituentTypes = type->AsUnionType()->ConstituentTypes();
+            for (auto *it : constituentTypes) {
+                if (MaybeTypeOfKind(it, kind)) {
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+bool Checker::IsConstantMemberAccess(const ir::Expression *expr)
+{
+    switch (expr->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            return true;
+        }
+        case ir::AstNodeType::MEMBER_EXPRESSION: {
+            bool res = IsConstantMemberAccess(expr->AsMemberExpression()->Object());
+            return !expr->AsMemberExpression()->IsComputed()
+                       ? res
+                       : (res && IsStringLike(expr->AsMemberExpression()->Property()));
+        }
+        default:
+            return false;
+    }
+}
+
+bool Checker::IsStringLike(const ir::Expression *expr)
+{
+    if (expr->IsStringLiteral()) {
+        return true;
+    }
+
+    if (expr->IsTemplateLiteral() && expr->AsTemplateLiteral()->Quasis().empty()) {
+        return true;
+    }
+
+    return false;
+}
+
+void Checker::CheckTruthinessOfType(Type *type, lexer::SourcePosition lineInfo)
+{
+    if (type->IsVoidType()) {
+        ThrowTypeError("An expression of type void cannot be tested for truthiness", lineInfo);
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/anyType.cpp b/es2panda/typescript/types/anyType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2ff37e3073cb0aa5c082e35e31c52fbf6ec8b37f
--- /dev/null
+++ b/es2panda/typescript/types/anyType.cpp
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "anyType.h"
+
+namespace panda::es2panda::checker {
+
+AnyType::AnyType() : Type(TypeFlag::ANY) {}
+
+void AnyType::ToString(std::stringstream &ss) const
+{
+    ss << "any";
+}
+
+void AnyType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsAnyType()) {
+        relation->Result(true);
+    }
+}
+
+void AnyType::AssignmentTarget(TypeRelation *relation, [[maybe_unused]] const Type *source) const
+{
+    relation->Result(true);
+}
+
+bool AnyType::AssignmentSource(TypeRelation *relation, [[maybe_unused]] const Type *target) const
+{
+    relation->Result(true);
+    return true;
+}
+
+TypeFacts AnyType::GetTypeFacts() const
+{
+    return TypeFacts::ALL;
+}
+
+Type *AnyType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                           [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/anyType.h b/es2panda/typescript/types/anyType.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf8800f8f5d2a9d8cf9675e45813021abcf51ed3
--- /dev/null
+++ b/es2panda/typescript/types/anyType.h
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ANY_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ANY_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class AnyType : public Type {
+public:
+    AnyType();
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    bool AssignmentSource(TypeRelation *relation, const Type *target) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_ANY_TYPE_H */
diff --git a/es2panda/typescript/types/arrayType.cpp b/es2panda/typescript/types/arrayType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..531131b3514bfb935056e951328f50b7a935ea49
--- /dev/null
+++ b/es2panda/typescript/types/arrayType.cpp
@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arrayType.h"
+
+#include <binder/variable.h>
+#include <typescript/types/objectType.h>
+
+namespace panda::es2panda::checker {
+
+ArrayType::ArrayType(Type *elementType) : Type(TypeFlag::ARRAY), element_(elementType) {}
+
+Type *ArrayType::ElementType()
+{
+    return element_;
+}
+
+const Type *ArrayType::ElementType() const
+{
+    return element_;
+}
+
+void ArrayType::ToString(std::stringstream &ss) const
+{
+    bool elemIsUnion = (element_->TypeFlags() == TypeFlag::UNION);
+    if (elemIsUnion) {
+        ss << "(";
+    }
+    ElementType()->ToString(ss);
+    if (elemIsUnion) {
+        ss << ")";
+    }
+    ss << "[]";
+}
+
+void ArrayType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsArrayType()) {
+        relation->IsIdenticalTo(element_, other->AsArrayType()->ElementType());
+    }
+}
+
+void ArrayType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsArrayType()) {
+        const Type *targetElementType = source->AsArrayType()->ElementType();
+        relation->IsAssignableTo(targetElementType, element_);
+    } else if (source->IsObjectType() && source->AsObjectType()->IsTupleType()) {
+        const ObjectType *sourceObj = source->AsObjectType();
+        for (const auto *it : sourceObj->Properties()) {
+            if (!relation->IsAssignableTo(it->TsType(), element_)) {
+                return;
+            }
+        }
+        relation->Result(true);
+    }
+}
+
+TypeFacts ArrayType::GetTypeFacts() const
+{
+    return TypeFacts::OBJECT_FACTS;
+}
+
+Type *ArrayType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    return allocator->New<ArrayType>(element_->Instantiate(allocator, relation, globalTypes));
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/arrayType.h b/es2panda/typescript/types/arrayType.h
new file mode 100644
index 0000000000000000000000000000000000000000..a28df06fbe47ba774dedda3b02429c3efc1788f4
--- /dev/null
+++ b/es2panda/typescript/types/arrayType.h
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ARRAY_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ARRAY_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class ArrayType : public Type {
+public:
+    explicit ArrayType(Type *elementType);
+
+    Type *ElementType();
+    const Type *ElementType() const;
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    Type *element_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_ARRAY_TYPE_H */
diff --git a/es2panda/typescript/types/bigintLiteralType.cpp b/es2panda/typescript/types/bigintLiteralType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..875731aaf7e627c83c87ba359a5b27855f6efcec
--- /dev/null
+++ b/es2panda/typescript/types/bigintLiteralType.cpp
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bigintLiteralType.h"
+
+namespace panda::es2panda::checker {
+
+BigintLiteralType::BigintLiteralType(util::StringView value, bool negative)
+    : Type(TypeFlag::BIGINT_LITERAL), value_(value), negative_(negative)
+{
+}
+
+const util::StringView &BigintLiteralType::Value() const
+{
+    return value_;
+}
+
+bool BigintLiteralType::Negative() const
+{
+    return negative_;
+}
+
+void BigintLiteralType::ToString(std::stringstream &ss) const
+{
+    ss << value_;
+}
+
+void BigintLiteralType::ToStringAsSrc(std::stringstream &ss) const
+{
+    ss << "bigint";
+}
+
+void BigintLiteralType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsBigintLiteralType()) {
+        if (negative_ == other->AsBigintLiteralType()->Negative()) {
+            relation->Result(value_ == other->AsBigintLiteralType()->Value());
+        }
+    }
+}
+
+void BigintLiteralType::AssignmentTarget([[maybe_unused]] TypeRelation *relation,
+                                         [[maybe_unused]] const Type *source) const
+{
+}
+
+TypeFacts BigintLiteralType::GetTypeFacts() const
+{
+    return value_.Is("0n") ? TypeFacts::ZERO_BIGINT_FACTS : TypeFacts::NON_ZERO_BIGINT_FACTS;
+}
+
+Type *BigintLiteralType::Instantiate([[maybe_unused]] ArenaAllocator *allocator,
+                                     [[maybe_unused]] TypeRelation *relation,
+                                     [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/bigintLiteralType.h b/es2panda/typescript/types/bigintLiteralType.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5d65269e00f8506c166e98084e4887f26e3474e
--- /dev/null
+++ b/es2panda/typescript/types/bigintLiteralType.h
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BIGINT_LITERAL_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BIGINT_LITERAL_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class BigintLiteralType : public Type {
+public:
+    BigintLiteralType(util::StringView value, bool negative);
+
+    const util::StringView &Value() const;
+    bool Negative() const;
+    void ToString(std::stringstream &ss) const override;
+    void ToStringAsSrc(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    util::StringView value_;
+    bool negative_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_BIGINT_LITERAL_TYPE_H */
diff --git a/es2panda/typescript/types/bigintType.cpp b/es2panda/typescript/types/bigintType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..448448a5eee70ed7b371121c0e66fc90ec647213
--- /dev/null
+++ b/es2panda/typescript/types/bigintType.cpp
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bigintType.h"
+
+namespace panda::es2panda::checker {
+
+BigintType::BigintType() : Type(TypeFlag::BIGINT) {}
+
+void BigintType::ToString(std::stringstream &ss) const
+{
+    ss << "bigint";
+}
+
+void BigintType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsBigintType()) {
+        relation->Result(true);
+    }
+}
+
+void BigintType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsBigintLiteralType()) {
+        relation->Result(true);
+    }
+}
+
+TypeFacts BigintType::GetTypeFacts() const
+{
+    return TypeFacts::BIGINT_FACTS;
+}
+
+Type *BigintType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                              [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/bigintType.h b/es2panda/typescript/types/bigintType.h
new file mode 100644
index 0000000000000000000000000000000000000000..948a73ee732dbddddf3550392b649c6e7adea63e
--- /dev/null
+++ b/es2panda/typescript/types/bigintType.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BIGINT_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BIGINT_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class BigintType : public Type {
+public:
+    BigintType();
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_BIGINT_TYPE_H */
diff --git a/es2panda/typescript/types/booleanLiteralType.cpp b/es2panda/typescript/types/booleanLiteralType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3c40713bc8c803b1b98d41d02f3a977b203f3b21
--- /dev/null
+++ b/es2panda/typescript/types/booleanLiteralType.cpp
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "booleanLiteralType.h"
+
+namespace panda::es2panda::checker {
+
+BooleanLiteralType::BooleanLiteralType(bool value) : Type(TypeFlag::BOOLEAN_LITERAL), value_(value) {}
+
+bool BooleanLiteralType::Value() const
+{
+    return value_;
+}
+
+void BooleanLiteralType::ToString(std::stringstream &ss) const
+{
+    if (value_) {
+        ss << "true";
+        return;
+    }
+
+    ss << "false";
+}
+
+void BooleanLiteralType::ToStringAsSrc(std::stringstream &ss) const
+{
+    ss << "boolean";
+}
+
+void BooleanLiteralType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsBooleanLiteralType()) {
+        relation->Result(other->AsBooleanLiteralType()->Value());
+    }
+}
+
+void BooleanLiteralType::AssignmentTarget([[maybe_unused]] TypeRelation *relation,
+                                          [[maybe_unused]] const Type *source) const
+{
+}
+
+TypeFacts BooleanLiteralType::GetTypeFacts() const
+{
+    return value_ ? TypeFacts::TRUE_FACTS : TypeFacts::FALSE_FACTS;
+}
+
+Type *BooleanLiteralType::Instantiate([[maybe_unused]] ArenaAllocator *allocator,
+                                      [[maybe_unused]] TypeRelation *relation,
+                                      [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/booleanLiteralType.h b/es2panda/typescript/types/booleanLiteralType.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a241c84bd1072b957e991a679f8a49dd844ef10
--- /dev/null
+++ b/es2panda/typescript/types/booleanLiteralType.h
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BOOLEAN_LITERAL_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BOOLEAN_LITERAL_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class BooleanLiteralType : public Type {
+public:
+    explicit BooleanLiteralType(bool value);
+
+    bool Value() const;
+    void ToString(std::stringstream &ss) const override;
+    void ToStringAsSrc(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    bool value_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_BOOLEAN_LITERAL_TYPE_H */
diff --git a/es2panda/typescript/types/booleanType.cpp b/es2panda/typescript/types/booleanType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9ad91f8285a22581c0a158bdae7330b7be4f476c
--- /dev/null
+++ b/es2panda/typescript/types/booleanType.cpp
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "booleanType.h"
+
+namespace panda::es2panda::checker {
+
+BooleanType::BooleanType() : Type(TypeFlag::BOOLEAN) {}
+
+void BooleanType::ToString(std::stringstream &ss) const
+{
+    ss << "boolean";
+}
+
+void BooleanType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsBooleanType()) {
+        relation->Result(true);
+    }
+}
+
+void BooleanType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsBooleanLiteralType()) {
+        relation->Result(true);
+    }
+}
+
+TypeFacts BooleanType::GetTypeFacts() const
+{
+    return TypeFacts::BOOLEAN_FACTS;
+}
+
+Type *BooleanType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                               [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/booleanType.h b/es2panda/typescript/types/booleanType.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef29e426247d778bc7fcf746a9303d6cf625479c
--- /dev/null
+++ b/es2panda/typescript/types/booleanType.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BOOLEAN_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_BOOLEAN_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class BooleanType : public Type {
+public:
+    BooleanType();
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_BOOLEAN_TYPE_H */
diff --git a/es2panda/typescript/types/constructorType.cpp b/es2panda/typescript/types/constructorType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a4e91da1d019472e239bcbd4000a936253d2174c
--- /dev/null
+++ b/es2panda/typescript/types/constructorType.cpp
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "constructorType.h"
+
+#include <typescript/types/signature.h>
+
+namespace panda::es2panda::checker {
+
+ConstructorType::ConstructorType(ObjectDescriptor *desc) : ObjectType(ObjectType::ObjectTypeKind::FUNCTION, desc) {}
+
+void ConstructorType::ToString(std::stringstream &ss) const
+{
+    if (desc_->constructSignatures.size() > 1) {
+        ss << "{ ";
+    }
+
+    for (auto it = desc_->constructSignatures.begin(); it != desc_->constructSignatures.end(); it++) {
+        (*it)->ToString(ss, variable_);
+        if (std::next(it) != desc_->constructSignatures.end()) {
+            ss << ", ";
+        }
+    }
+
+    if (desc_->constructSignatures.size() > 1) {
+        ss << " }";
+    }
+}
+
+TypeFacts ConstructorType::GetTypeFacts() const
+{
+    return TypeFacts::FUNCTION_FACTS;
+}
+
+Type *ConstructorType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    ObjectDescriptor *copiedDesc = allocator->New<ObjectDescriptor>();
+    desc_->Copy(allocator, copiedDesc, relation, globalTypes);
+    return allocator->New<ConstructorType>(copiedDesc);
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/constructorType.h b/es2panda/typescript/types/constructorType.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8f62a2e86a6440803d689960433d4dc00295a22
--- /dev/null
+++ b/es2panda/typescript/types/constructorType.h
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_CONSTRUCTOR_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_CONSTRUCTOR_TYPE_H
+
+#include "objectType.h"
+
+namespace panda::es2panda::checker {
+
+class ConstructorType : public ObjectType {
+public:
+    explicit ConstructorType(ObjectDescriptor *desc);
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_CONSTRUCTOR_TYPE_H */
diff --git a/es2panda/typescript/types/elementFlags.h b/es2panda/typescript/types/elementFlags.h
new file mode 100644
index 0000000000000000000000000000000000000000..ed79ff4d9a017943bf3fe2f138f78ce563ed6322
--- /dev/null
+++ b/es2panda/typescript/types/elementFlags.h
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ELEMENT_FLAGS_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ELEMENT_FLAGS_H
+
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::checker {
+
+enum class ElementFlags {
+    NO_OPTS = 0,
+    REQUIRED = 1 << 0,  // T
+    OPTIONAL = 1 << 1,  // T?
+    REST = 1 << 2,      // ...T[]
+    VARIADIC = 1 << 3,  // ...T
+    FIXED = REQUIRED | OPTIONAL,
+    VARIABLE = REST | VARIADIC,
+    NON_REQUIRED = OPTIONAL | REST | VARIADIC,
+    NON_REST = REQUIRED | OPTIONAL | VARIADIC,
+};
+
+DEFINE_BITOPS(ElementFlags)
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_ELEMENT_FLAGS_H */
diff --git a/es2panda/typescript/types/enumLiteralType.cpp b/es2panda/typescript/types/enumLiteralType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..029e039970545c1653304869f31c6badec167c12
--- /dev/null
+++ b/es2panda/typescript/types/enumLiteralType.cpp
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "enumLiteralType.h"
+
+#include <binder/variable.h>
+#include <typescript/types/enumType.h>
+
+namespace panda::es2panda::checker {
+
+EnumLiteralType::EnumLiteralType(util::StringView name, binder::Scope *scope, EnumLiteralTypeKind kind)
+    : Type(TypeFlag::ENUM_LITERAL), name_(name), scope_(scope), kind_(kind)
+{
+}
+
+binder::Scope *EnumLiteralType::Scope()
+{
+    return scope_;
+}
+
+const binder::Scope *EnumLiteralType::Scope() const
+{
+    return scope_;
+}
+
+void EnumLiteralType::ToString(std::stringstream &ss) const
+{
+    ss << name_;
+}
+
+void EnumLiteralType::ToStringAsSrc(std::stringstream &ss) const
+{
+    ss << "typeof " << name_;
+}
+
+EnumLiteralType::EnumLiteralTypeKind EnumLiteralType::Kind() const
+{
+    return kind_;
+}
+
+void EnumLiteralType::Identical([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *other) const {}
+
+void EnumLiteralType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsEnumType()) {
+        const EnumType *sourceEnumType = source->AsEnumType();
+
+        if (variable_ == sourceEnumType->EnumVar()) {
+            relation->Result(true);
+        }
+    } else if (source->HasTypeFlag(TypeFlag::NUMBER_LIKE)) {
+        relation->Result(true);
+    }
+}
+
+TypeFacts EnumLiteralType::GetTypeFacts() const
+{
+    return TypeFacts::NUMBER_FACTS;
+}
+
+Type *EnumLiteralType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                                   [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return allocator->New<EnumLiteralType>(name_, scope_, kind_);
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/enumLiteralType.h b/es2panda/typescript/types/enumLiteralType.h
new file mode 100644
index 0000000000000000000000000000000000000000..5af0ec4a4f4334233e41705ffd0ed7540e92586c
--- /dev/null
+++ b/es2panda/typescript/types/enumLiteralType.h
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ENUM_LITERAL_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ENUM_LITERAL_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::binder {
+class Scope;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::checker {
+
+class EnumLiteralType : public Type {
+public:
+    enum class EnumLiteralTypeKind { NUMERIC, LITERAL };
+    EnumLiteralType(util::StringView name, binder::Scope *scope, EnumLiteralTypeKind kind);
+
+    binder::Scope *Scope();
+    const binder::Scope *Scope() const;
+    EnumLiteralTypeKind Kind() const;
+
+    void ToString(std::stringstream &ss) const override;
+    void ToStringAsSrc(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    util::StringView name_;
+    binder::Scope *scope_;
+    EnumLiteralTypeKind kind_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_ENUM_LITERAL_TYPE_H */
diff --git a/es2panda/typescript/types/enumType.cpp b/es2panda/typescript/types/enumType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..040b2b35c1c0ec6eccccdca9351c28c4b2daba70
--- /dev/null
+++ b/es2panda/typescript/types/enumType.cpp
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "enumType.h"
+
+#include <binder/variable.h>
+
+namespace panda::es2panda::checker {
+
+EnumType::EnumType(binder::Variable *enumLiteralVar, binder::EnumVariable *enumVar)
+    : Type(TypeFlag::ENUM), enumLiteralVar_(enumLiteralVar), enumVar_(enumVar)
+{
+}
+
+const binder::Variable *EnumType::EnumLiteralVar() const
+{
+    return enumLiteralVar_;
+}
+
+const binder::EnumVariable *EnumType::EnumVar() const
+{
+    return enumVar_;
+}
+
+void EnumType::ToString(std::stringstream &ss) const
+{
+    ss << enumLiteralVar_->Name() << "." << enumVar_->Name();
+}
+
+void EnumType::Identical([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *other) const
+{
+    // TODO(aszilagyi)
+}
+
+void EnumType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsNumberLiteralType()) {
+        relation->Result(true);
+    }
+}
+
+TypeFacts EnumType::GetTypeFacts() const
+{
+    // TODO(aszilagyi)
+    return TypeFacts::NUMBER_FACTS;
+}
+
+Type *EnumType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                            [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    // TODO(aszilagyi)
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/enumType.h b/es2panda/typescript/types/enumType.h
new file mode 100644
index 0000000000000000000000000000000000000000..1038eba2a581ac8e5b9743f1b5913e1c847d7fb3
--- /dev/null
+++ b/es2panda/typescript/types/enumType.h
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ENUM_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_ENUM_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::binder {
+class EnumVariable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::checker {
+
+class EnumType : public Type {
+public:
+    EnumType(binder::Variable *enumLiteralVar, binder::EnumVariable *enumVar);
+
+    const binder::Variable *EnumLiteralVar() const;
+    const binder::EnumVariable *EnumVar() const;
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    binder::Variable *enumLiteralVar_;
+    binder::EnumVariable *enumVar_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_ENUM_TYPE_H */
diff --git a/es2panda/typescript/types/functionType.cpp b/es2panda/typescript/types/functionType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bdad12e4db3ca7f6d5a2986003daa5befbb3672d
--- /dev/null
+++ b/es2panda/typescript/types/functionType.cpp
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "functionType.h"
+
+#include <typescript/types/signature.h>
+
+namespace panda::es2panda::checker {
+
+FunctionType::FunctionType(ObjectDescriptor *desc) : ObjectType(ObjectType::ObjectTypeKind::FUNCTION, desc) {}
+
+void FunctionType::ToString(std::stringstream &ss) const
+{
+    static std::unordered_set<const FunctionType *> stack;
+
+    if (stack.find(this) != stack.end()) {
+        stack.erase(this);
+        ss << "...";
+        return;
+    }
+
+    stack.insert(this);
+
+    if (desc_->callSignatures.size() > 1) {
+        ss << "{ ";
+    }
+
+    for (auto it = desc_->callSignatures.begin(); it != desc_->callSignatures.end(); it++) {
+        (*it)->ToString(ss, variable_, desc_->callSignatures.size() > 1);
+        if (std::next(it) != desc_->callSignatures.end()) {
+            ss << ", ";
+        }
+    }
+
+    if (desc_->callSignatures.size() > 1) {
+        ss << " }";
+    }
+}
+
+TypeFacts FunctionType::GetTypeFacts() const
+{
+    return TypeFacts::FUNCTION_FACTS;
+}
+
+Type *FunctionType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    ObjectDescriptor *copiedDesc = allocator->New<ObjectDescriptor>();
+    desc_->Copy(allocator, copiedDesc, relation, globalTypes);
+    return allocator->New<FunctionType>(copiedDesc);
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/functionType.h b/es2panda/typescript/types/functionType.h
new file mode 100644
index 0000000000000000000000000000000000000000..751996d04129a07ac78a1db7204c219536c4500e
--- /dev/null
+++ b/es2panda/typescript/types/functionType.h
@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_FUNCTION_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_FUNCTION_TYPE_H
+
+#include <unordered_set>
+#include "objectType.h"
+
+namespace panda::es2panda::checker {
+
+class FunctionType : public ObjectType {
+public:
+    explicit FunctionType(ObjectDescriptor *desc);
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_FUNCTION_TYPE_H */
diff --git a/es2panda/typescript/types/globalTypesHolder.cpp b/es2panda/typescript/types/globalTypesHolder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c944b943cea04b9cb005b095daf3cb407d8def35
--- /dev/null
+++ b/es2panda/typescript/types/globalTypesHolder.cpp
@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "globalTypesHolder.h"
+
+#include <typescript/types/numberType.h>
+#include <typescript/types/anyType.h>
+#include <typescript/types/stringType.h>
+#include <typescript/types/booleanType.h>
+#include <typescript/types/voidType.h>
+#include <typescript/types/nullType.h>
+#include <typescript/types/undefinedType.h>
+#include <typescript/types/unknownType.h>
+#include <typescript/types/neverType.h>
+#include <typescript/types/nonPrimitiveType.h>
+#include <typescript/types/bigintType.h>
+#include <typescript/types/booleanLiteralType.h>
+#include <typescript/types/bigintLiteralType.h>
+#include <typescript/types/numberLiteralType.h>
+#include <typescript/types/stringLiteralType.h>
+#include <typescript/types/tupleType.h>
+#include <typescript/types/objectLiteralType.h>
+#include <typescript/types/unionType.h>
+
+namespace panda::es2panda::checker {
+
+GlobalTypesHolder::GlobalTypesHolder(ArenaAllocator *allocator)
+{
+    globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
+    globalTypes_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
+    globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
+        allocator->New<UnionType>(std::initializer_list<Type *> {GlobalNumberType(), GlobalBigintType()});
+    globalTypes_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
+        allocator->New<UnionType>(std::initializer_list<Type *> {GlobalStringType(), GlobalNumberType()});
+    globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
+    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
+    globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
+    globalTypes_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
+        std::initializer_list<Type *> {GlobalNumberType(), GlobalStringType(), GlobalBigintType(), GlobalBooleanType(),
+                                       GlobalVoidType(), GlobalUndefinedType(), GlobalNullType()});
+    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>();
+    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
+}
+
+Type *GlobalTypesHolder::GlobalNumberType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
+}
+
+Type *GlobalTypesHolder::GlobalAnyType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ANY));
+}
+
+Type *GlobalTypesHolder::GlobalStringType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING));
+}
+
+Type *GlobalTypesHolder::GlobalBooleanType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
+}
+
+Type *GlobalTypesHolder::GlobalVoidType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::VOID));
+}
+
+Type *GlobalTypesHolder::GlobalNullType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
+}
+
+Type *GlobalTypesHolder::GlobalUndefinedType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
+}
+
+Type *GlobalTypesHolder::GlobalUnknownType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
+}
+
+Type *GlobalTypesHolder::GlobalNeverType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NEVER));
+}
+
+Type *GlobalTypesHolder::GlobalNonPrimitiveType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
+}
+
+Type *GlobalTypesHolder::GlobalBigintType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
+}
+
+Type *GlobalTypesHolder::GlobalFalseType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
+}
+
+Type *GlobalTypesHolder::GlobalTrueType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
+}
+
+Type *GlobalTypesHolder::GlobalNumberOrBigintType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
+}
+
+Type *GlobalTypesHolder::GlobalStringOrNumberType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
+}
+
+Type *GlobalTypesHolder::GlobalZeroType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO));
+}
+
+Type *GlobalTypesHolder::GlobalEmptyStringType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
+}
+
+Type *GlobalTypesHolder::GlobalZeroBigintType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
+}
+
+Type *GlobalTypesHolder::GlobalPrimitiveType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
+}
+
+Type *GlobalTypesHolder::GlobalEmptyTupleType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
+}
+
+Type *GlobalTypesHolder::GlobalEmptyObjectType()
+{
+    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/globalTypesHolder.h b/es2panda/typescript/types/globalTypesHolder.h
new file mode 100644
index 0000000000000000000000000000000000000000..83fb925fb4ae75e589326667e2ecc841b884b000
--- /dev/null
+++ b/es2panda/typescript/types/globalTypesHolder.h
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_GLOBAL_TYPES_HOLDER_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_GLOBAL_TYPES_HOLDER_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+enum class GlobalTypeId {
+    NUMBER,
+    ANY,
+    STRING,
+    BOOLEAN,
+    VOID,
+    NULL_ID,
+    UNDEFINED,
+    UNKNOWN,
+    NEVER,
+    NON_PRIMITIVE,
+    BIGINT,
+    FALSE_ID,
+    TRUE_ID,
+    NUMBER_OR_BIGINT,
+    STRING_OR_NUMBER,
+    ZERO,
+    EMPTY_STRING,
+    ZERO_BIGINT,
+    PRIMITIVE,
+    EMPTY_TUPLE,
+    EMPTY_OBJECT,
+    COUNT
+};
+
+class GlobalTypesHolder {
+public:
+    explicit GlobalTypesHolder(ArenaAllocator *allocator);
+    ~GlobalTypesHolder() = default;
+    NO_COPY_SEMANTIC(GlobalTypesHolder);
+    NO_MOVE_SEMANTIC(GlobalTypesHolder);
+
+    Type *GlobalNumberType();
+    Type *GlobalAnyType();
+    Type *GlobalStringType();
+    Type *GlobalBooleanType();
+    Type *GlobalVoidType();
+    Type *GlobalNullType();
+    Type *GlobalUndefinedType();
+    Type *GlobalUnknownType();
+    Type *GlobalNeverType();
+    Type *GlobalNonPrimitiveType();
+    Type *GlobalBigintType();
+    Type *GlobalFalseType();
+    Type *GlobalTrueType();
+    Type *GlobalNumberOrBigintType();
+    Type *GlobalStringOrNumberType();
+    Type *GlobalZeroType();
+    Type *GlobalEmptyStringType();
+    Type *GlobalZeroBigintType();
+    Type *GlobalPrimitiveType();
+    Type *GlobalEmptyTupleType();
+    Type *GlobalEmptyObjectType();
+
+private:
+    std::array<Type *, static_cast<size_t>(GlobalTypeId::COUNT)> globalTypes_ {};
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* ES2PANDA_COMPILER_TYPESCRIPT_TYPES_GLOBAL_TYPES_HOLDER_H */
diff --git a/es2panda/typescript/types/indexInfo.cpp b/es2panda/typescript/types/indexInfo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5aad2d190144c3621506368749e444db5db2d0ff
--- /dev/null
+++ b/es2panda/typescript/types/indexInfo.cpp
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "indexInfo.h"
+
+#include <utility>
+
+namespace panda::es2panda::checker {
+
+IndexInfo::IndexInfo(Type *type, util::StringView paramName, bool readonly)
+    : type_(type), paramName_(paramName), readonly_(readonly)
+{
+}
+
+Type *IndexInfo::InfoType()
+{
+    return type_;
+}
+
+const Type *IndexInfo::InfoType() const
+{
+    return type_;
+}
+
+void IndexInfo::SetInfoType(class Type *type)
+{
+    type_ = type;
+}
+
+const util::StringView &IndexInfo::ParamName()
+{
+    return paramName_;
+}
+
+IndexInfo *IndexInfo::Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    return allocator->New<IndexInfo>(type_->Instantiate(allocator, relation, globalTypes), paramName_, readonly_);
+}
+
+void IndexInfo::ToString(std::stringstream &ss, bool numIndex) const
+{
+    if (readonly_) {
+        ss << "readonly ";
+    }
+
+    ss << "[" << paramName_ << ": ";
+
+    if (numIndex) {
+        ss << "number]: ";
+    } else {
+        ss << "string]: ";
+    }
+
+    type_->ToString(ss);
+}
+
+void IndexInfo::Identical(TypeRelation *relation, const IndexInfo *other) const
+{
+    relation->IsIdenticalTo(type_, other->InfoType());
+}
+
+void IndexInfo::AssignmentTarget(TypeRelation *relation, const IndexInfo *source) const
+{
+    relation->IsAssignableTo(source->InfoType(), type_);
+}
+
+bool IndexInfo::Readonly() const
+{
+    return readonly_;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/indexInfo.h b/es2panda/typescript/types/indexInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..c20ee43ae4ca8caf045baa4a6033591109da69a2
--- /dev/null
+++ b/es2panda/typescript/types/indexInfo.h
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_INDEX_INFO_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_INDEX_INFO_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class IndexInfo {
+public:
+    IndexInfo(Type *type, util::StringView paramName, bool readonly = false);
+    ~IndexInfo() = default;
+    NO_COPY_SEMANTIC(IndexInfo);
+    NO_MOVE_SEMANTIC(IndexInfo);
+
+    Type *InfoType();
+    const Type *InfoType() const;
+    bool Readonly() const;
+    void SetInfoType(Type *type);
+    const util::StringView &ParamName();
+
+    void ToString(std::stringstream &ss, bool numIndex = true) const;
+    void Identical(TypeRelation *relation, const IndexInfo *other) const;
+    void AssignmentTarget(TypeRelation *relation, const IndexInfo *source) const;
+    IndexInfo *Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes);
+
+private:
+    Type *type_;
+    util::StringView paramName_;
+    bool readonly_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_INDEX_INFO_H */
diff --git a/es2panda/typescript/types/interfaceType.cpp b/es2panda/typescript/types/interfaceType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8f1fbb3057210611ab50799cfeff6c179a7d1b02
--- /dev/null
+++ b/es2panda/typescript/types/interfaceType.cpp
@@ -0,0 +1,306 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "interfaceType.h"
+
+#include <binder/variable.h>
+#include <typescript/types/typeParameter.h>
+
+#include <algorithm>
+#include <utility>
+
+namespace panda::es2panda::checker {
+
+InterfaceType::InterfaceType(util::StringView name, ObjectDescriptor *desc)
+    : ObjectType(ObjectType::ObjectTypeKind::INTERFACE, desc), name_(name)
+{
+}
+
+void InterfaceType::AddBase(ObjectType *base)
+{
+    bases_.push_back(base);
+}
+
+const std::vector<ObjectType *> &InterfaceType::Bases() const
+{
+    return bases_;
+}
+
+const util::StringView &InterfaceType::Name() const
+{
+    return name_;
+}
+
+void InterfaceType::SetMergedTypeParams(std::pair<std::vector<binder::Variable *>, size_t> &&mergedTypeParams)
+{
+    mergedTypeParams_ = std::move(mergedTypeParams);
+}
+
+const std::pair<std::vector<binder::Variable *>, size_t> &InterfaceType::GetMergedTypeParams() const
+{
+    return mergedTypeParams_;
+}
+
+void InterfaceType::SetTypeParamTypes(std::vector<Type *> &&typeParamTypes)
+{
+    typeParamTypes_ = std::move(typeParamTypes);
+}
+
+const std::vector<Type *> &InterfaceType::GetTypeParamTypes() const
+{
+    return typeParamTypes_;
+}
+
+binder::LocalVariable *InterfaceType::GetProperty(const util::StringView &name) const
+{
+    binder::LocalVariable *resultProp = ObjectType::GetProperty(name);
+
+    if (resultProp) {
+        return resultProp;
+    }
+
+    for (auto *base : bases_) {
+        resultProp = base->GetProperty(name);
+        if (resultProp) {
+            return resultProp;
+        }
+    }
+
+    return nullptr;
+}
+
+void InterfaceType::ToString(std::stringstream &ss) const
+{
+    ss << name_;
+
+    if (!typeParamTypes_.empty()) {
+        ss << "<";
+
+        for (auto it = typeParamTypes_.begin(); it != typeParamTypes_.end(); it++) {
+            (*it)->ToString(ss);
+
+            if (std::next(it) != typeParamTypes_.end()) {
+                ss << ", ";
+            }
+        }
+
+        ss << ">";
+    }
+}
+
+void InterfaceType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (!other->IsObjectType() || !other->AsObjectType()->IsInterfaceType()) {
+        return;
+    }
+
+    const InterfaceType *otherInterface = other->AsObjectType()->AsInterfaceType();
+
+    std::vector<binder::LocalVariable *> targetProperties;
+    CollectProperties(&targetProperties);
+
+    std::vector<binder::LocalVariable *> sourceProperties;
+    otherInterface->CollectProperties(&sourceProperties);
+
+    if (targetProperties.size() != sourceProperties.size()) {
+        relation->Result(false);
+        return;
+    }
+
+    for (const auto *targetProp : targetProperties) {
+        bool foundProp = std::any_of(sourceProperties.begin(), sourceProperties.end(),
+                                     [targetProp, relation](const binder::LocalVariable *sourceProp) {
+                                         if (targetProp->Name() == sourceProp->Name()) {
+                                             return relation->IsIdenticalTo(targetProp->TsType(), sourceProp->TsType());
+                                         }
+
+                                         return false;
+                                     });
+        if (!foundProp) {
+            relation->Result(false);
+            return;
+        }
+    }
+
+    std::vector<Signature *> targetCallSignatures;
+    CollectSignatures(&targetCallSignatures, true);
+
+    std::vector<Signature *> sourceCallSignatures;
+    otherInterface->CollectSignatures(&sourceCallSignatures, true);
+
+    if (targetCallSignatures.size() != sourceCallSignatures.size()) {
+        relation->Result(false);
+        return;
+    }
+
+    if (!EachSignatureRelatedToSomeSignature(relation, targetCallSignatures, sourceCallSignatures) ||
+        !EachSignatureRelatedToSomeSignature(relation, sourceCallSignatures, targetCallSignatures)) {
+        return;
+    }
+
+    std::vector<Signature *> targetConstructSignatures;
+    CollectSignatures(&targetConstructSignatures, false);
+
+    std::vector<Signature *> sourceConstructSignatures;
+    otherInterface->CollectSignatures(&sourceConstructSignatures, false);
+
+    if (targetConstructSignatures.size() != sourceConstructSignatures.size()) {
+        relation->Result(false);
+        return;
+    }
+
+    if (!EachSignatureRelatedToSomeSignature(relation, targetConstructSignatures, sourceConstructSignatures) ||
+        !EachSignatureRelatedToSomeSignature(relation, sourceConstructSignatures, targetConstructSignatures)) {
+        return;
+    }
+
+    const IndexInfo *targetNumberInfo = FindIndexInfo(true);
+    const IndexInfo *sourceNumberInfo = otherInterface->FindIndexInfo(true);
+
+    if ((targetNumberInfo && !sourceNumberInfo) || (!targetNumberInfo && sourceNumberInfo)) {
+        relation->Result(false);
+        return;
+    }
+
+    relation->IsIdenticalTo(targetNumberInfo, sourceNumberInfo);
+
+    if (relation->IsTrue()) {
+        const IndexInfo *targetStringInfo = FindIndexInfo(false);
+        const IndexInfo *sourceStringInfo = otherInterface->FindIndexInfo(false);
+
+        if ((targetStringInfo && !sourceStringInfo) || (!targetStringInfo && sourceStringInfo)) {
+            relation->Result(false);
+            return;
+        }
+
+        relation->IsIdenticalTo(targetStringInfo, sourceStringInfo);
+    }
+}
+
+Type *InterfaceType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    ObjectDescriptor *copiedDesc = allocator->New<ObjectDescriptor>();
+
+    desc_->Copy(allocator, copiedDesc, relation, globalTypes);
+
+    Type *newInterfaceType = allocator->New<InterfaceType>(name_, copiedDesc);
+
+    for (auto *it : bases_) {
+        newInterfaceType->AsObjectType()->AsInterfaceType()->AddBase(
+            it->Instantiate(allocator, relation, globalTypes)->AsObjectType());
+    }
+
+    return newInterfaceType;
+}
+
+void InterfaceType::CollectSignatures(std::vector<Signature *> *collectedSignatures, bool collectCallSignatures) const
+{
+    if (collectCallSignatures) {
+        for (auto *it : CallSignatures()) {
+            collectedSignatures->push_back(it);
+        }
+    } else {
+        for (auto *it : ConstructSignatures()) {
+            collectedSignatures->push_back(it);
+        }
+    }
+
+    for (auto *it : bases_) {
+        it->AsInterfaceType()->CollectSignatures(collectedSignatures, collectCallSignatures);
+    }
+}
+
+void InterfaceType::CollectProperties(std::vector<binder::LocalVariable *> *collectedPropeties) const
+{
+    for (auto *currentProp : Properties()) {
+        bool propAlreadyCollected = false;
+        for (auto *collectedProp : *collectedPropeties) {
+            if (currentProp->Name() == collectedProp->Name()) {
+                propAlreadyCollected = true;
+                break;
+            }
+        }
+
+        if (propAlreadyCollected) {
+            continue;
+        }
+
+        collectedPropeties->push_back(currentProp);
+    }
+
+    for (auto *it : bases_) {
+        it->AsInterfaceType()->CollectProperties(collectedPropeties);
+    }
+}
+
+const IndexInfo *InterfaceType::FindIndexInfo(bool findNumberInfo) const
+{
+    const IndexInfo *foundInfo = nullptr;
+
+    if (findNumberInfo && NumberIndexInfo()) {
+        foundInfo = NumberIndexInfo();
+    } else if (!findNumberInfo && StringIndexInfo()) {
+        foundInfo = StringIndexInfo();
+    }
+
+    for (auto it = bases_.begin(); it != bases_.end() && !foundInfo; it++) {
+        foundInfo = (*it)->AsInterfaceType()->FindIndexInfo(findNumberInfo);
+    }
+
+    return foundInfo;
+}
+
+IndexInfo *InterfaceType::FindIndexInfo(bool findNumberInfo)
+{
+    IndexInfo *foundInfo = nullptr;
+
+    if (findNumberInfo && NumberIndexInfo()) {
+        foundInfo = NumberIndexInfo();
+    } else if (!findNumberInfo && StringIndexInfo()) {
+        foundInfo = StringIndexInfo();
+    }
+
+    for (auto it = bases_.begin(); it != bases_.end() && !foundInfo; it++) {
+        foundInfo = (*it)->AsInterfaceType()->FindIndexInfo(findNumberInfo);
+    }
+
+    return foundInfo;
+}
+
+TypeFacts InterfaceType::GetTypeFacts() const
+{
+    if (desc_->properties.empty() && desc_->callSignatures.empty() && desc_->constructSignatures.empty() &&
+        !desc_->stringIndexInfo && !desc_->numberIndexInfo) {
+        if (bases_.empty()) {
+            return TypeFacts::EMPTY_OBJECT_FACTS;
+        }
+
+        bool isEmpty = true;
+        for (auto it = bases_.begin(); isEmpty && it != bases_.end(); it++) {
+            if (!(*it)->Properties().empty() || !(*it)->CallSignatures().empty() ||
+                !(*it)->ConstructSignatures().empty() || (*it)->StringIndexInfo() || (*it)->NumberIndexInfo()) {
+                isEmpty = false;
+            }
+        }
+
+        if (isEmpty) {
+            return TypeFacts::EMPTY_OBJECT_FACTS;
+        }
+    }
+
+    return TypeFacts::OBJECT_FACTS;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/interfaceType.h b/es2panda/typescript/types/interfaceType.h
new file mode 100644
index 0000000000000000000000000000000000000000..f46f3952405ef402abaf4bb424cbb2a922220421
--- /dev/null
+++ b/es2panda/typescript/types/interfaceType.h
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_INTERFACE_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_INTERFACE_TYPE_H
+
+#include "objectType.h"
+
+namespace panda::es2panda::checker {
+
+class InterfaceType : public ObjectType {
+public:
+    InterfaceType(util::StringView name, ObjectDescriptor *desc);
+
+    void AddBase(ObjectType *base);
+    const std::vector<ObjectType *> &Bases() const;
+    const util::StringView &Name() const;
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+    binder::LocalVariable *GetProperty(const util::StringView &name) const override;
+    void SetMergedTypeParams(std::pair<std::vector<binder::Variable *>, size_t> &&mergedTypeParams);
+    const std::pair<std::vector<binder::Variable *>, size_t> &GetMergedTypeParams() const;
+    void SetTypeParamTypes(std::vector<Type *> &&typeParamTypes);
+    const std::vector<Type *> &GetTypeParamTypes() const;
+
+    void CollectSignatures(std::vector<Signature *> *collectedSignatures, bool collectCallSignatures) const;
+    void CollectProperties(std::vector<binder::LocalVariable *> *collectedPropeties) const;
+    const IndexInfo *FindIndexInfo(bool findNumberInfo) const;
+    IndexInfo *FindIndexInfo(bool findNumberInfo);
+
+private:
+    util::StringView name_;
+    std::vector<ObjectType *> bases_;
+    std::pair<std::vector<binder::Variable *>, size_t> mergedTypeParams_ {};
+    std::vector<Type *> typeParamTypes_ {};
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_INTERFACE_TYPE_H */
diff --git a/es2panda/typescript/types/neverType.cpp b/es2panda/typescript/types/neverType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b956612204be518d15962da7d9d30537ccb82a94
--- /dev/null
+++ b/es2panda/typescript/types/neverType.cpp
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "neverType.h"
+
+namespace panda::es2panda::checker {
+
+NeverType::NeverType() : Type(TypeFlag::NEVER) {}
+
+void NeverType::ToString(std::stringstream &ss) const
+{
+    ss << "never";
+}
+
+TypeFacts NeverType::GetTypeFacts() const
+{
+    return TypeFacts::NONE;
+}
+
+void NeverType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsNeverType()) {
+        relation->Result(true);
+    }
+}
+
+void NeverType::AssignmentTarget(TypeRelation *relation, [[maybe_unused]] const Type *source) const
+{
+    relation->Result(false);
+}
+
+bool NeverType::AssignmentSource(TypeRelation *relation, [[maybe_unused]] const Type *target) const
+{
+    relation->Result(true);
+    return true;
+}
+
+Type *NeverType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                             [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/neverType.h b/es2panda/typescript/types/neverType.h
new file mode 100644
index 0000000000000000000000000000000000000000..36d7370948b282c6b6003523310ae57753114cbd
--- /dev/null
+++ b/es2panda/typescript/types/neverType.h
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NEVER_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NEVER_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class NeverType : public Type {
+public:
+    NeverType();
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    bool AssignmentSource(TypeRelation *relation, const Type *target) const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_NEVER_TYPE_H */
diff --git a/es2panda/typescript/types/nonPrimitiveType.cpp b/es2panda/typescript/types/nonPrimitiveType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ebf523c5e7c68c6151fe993e0c5ceeca98ff6bae
--- /dev/null
+++ b/es2panda/typescript/types/nonPrimitiveType.cpp
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "nonPrimitiveType.h"
+
+namespace panda::es2panda::checker {
+
+NonPrimitiveType::NonPrimitiveType() : Type(TypeFlag::NON_PRIMITIVE) {}
+
+void NonPrimitiveType::ToString(std::stringstream &ss) const
+{
+    ss << "object";
+}
+
+void NonPrimitiveType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsNonPrimitiveType()) {
+        relation->Result(true);
+    }
+}
+
+void NonPrimitiveType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsObjectType()) {
+        relation->Result(true);
+    }
+}
+
+TypeFacts NonPrimitiveType::GetTypeFacts() const
+{
+    return TypeFacts::OBJECT_FACTS;
+}
+
+Type *NonPrimitiveType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                                    [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/nonPrimitiveType.h b/es2panda/typescript/types/nonPrimitiveType.h
new file mode 100644
index 0000000000000000000000000000000000000000..2573b895a4a6bd0af7b3743683f4150af3751161
--- /dev/null
+++ b/es2panda/typescript/types/nonPrimitiveType.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NON_PRIMITIVE_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NON_PRIMITIVE_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class NonPrimitiveType : public Type {
+public:
+    NonPrimitiveType();
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_NON_PRIMITIVE_TYPE_H */
diff --git a/es2panda/typescript/types/nullType.cpp b/es2panda/typescript/types/nullType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..00b4b2c2b6adb1f8c84719b64bcdce2966c5623d
--- /dev/null
+++ b/es2panda/typescript/types/nullType.cpp
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "nullType.h"
+
+namespace panda::es2panda::checker {
+
+NullType::NullType() : Type(TypeFlag::NULL_TYPE) {}
+
+void NullType::ToString(std::stringstream &ss) const
+{
+    ss << "null";
+}
+
+void NullType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsNullType()) {
+        relation->Result(true);
+    }
+}
+
+bool NullType::AssignmentSource(TypeRelation *relation, [[maybe_unused]] const Type *target) const
+{
+    relation->Result(!target->IsNeverType());
+    return relation->IsTrue();
+}
+
+void NullType::AssignmentTarget([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *source) const {}
+
+TypeFacts NullType::GetTypeFacts() const
+{
+    return TypeFacts::NULL_FACTS;
+}
+
+Type *NullType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                            [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/nullType.h b/es2panda/typescript/types/nullType.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d42ec2010cb06ad995169cbd8194e73f9799a73
--- /dev/null
+++ b/es2panda/typescript/types/nullType.h
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NULL_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NULL_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class NullType : public Type {
+public:
+    NullType();
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    bool AssignmentSource(TypeRelation *relation, const Type *target) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_NULL_TYPE_H */
diff --git a/es2panda/typescript/types/numberLiteralType.cpp b/es2panda/typescript/types/numberLiteralType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..30317a26bb5e4e42f7b95731fcfd825310721f40
--- /dev/null
+++ b/es2panda/typescript/types/numberLiteralType.cpp
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "numberLiteralType.h"
+
+#include <util/helpers.h>
+#include <binder/variable.h>
+#include <typescript/types/enumType.h>
+
+namespace panda::es2panda::checker {
+
+NumberLiteralType::NumberLiteralType(double value) : Type(TypeFlag::NUMBER_LITERAL), value_(value) {}
+
+double NumberLiteralType::Value() const
+{
+    return value_;
+}
+
+void NumberLiteralType::ToString(std::stringstream &ss) const
+{
+    ss << util::Helpers::ToString(value_);
+}
+
+void NumberLiteralType::ToStringAsSrc(std::stringstream &ss) const
+{
+    ss << "number";
+}
+
+void NumberLiteralType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsNumberLiteralType()) {
+        relation->Result(value_ == other->AsNumberLiteralType()->Value());
+    }
+}
+
+void NumberLiteralType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsEnumType()) {
+        const EnumType *sourceEnumType = source->AsEnumType();
+        const binder::EnumVariable *enumVar = sourceEnumType->EnumVar();
+
+        if (std::holds_alternative<double>(enumVar->Value()) && value_ == std::get<double>(enumVar->Value())) {
+            relation->Result(true);
+        }
+    }
+}
+
+TypeFacts NumberLiteralType::GetTypeFacts() const
+{
+    return value_ == 0 ? TypeFacts::ZERO_NUMBER_FACTS : TypeFacts::NON_ZERO_NUMBER_FACTS;
+}
+
+Type *NumberLiteralType::Instantiate([[maybe_unused]] ArenaAllocator *allocator,
+                                     [[maybe_unused]] TypeRelation *relation,
+                                     [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/numberLiteralType.h b/es2panda/typescript/types/numberLiteralType.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b472e6f614493f2e1f5ea93b4c28b2fa48bb71b
--- /dev/null
+++ b/es2panda/typescript/types/numberLiteralType.h
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NUMBER_LITERAL_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NUMBER_LITERAL_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class NumberLiteralType : public Type {
+public:
+    explicit NumberLiteralType(double value);
+
+    double Value() const;
+    void ToString(std::stringstream &ss) const override;
+    void ToStringAsSrc(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    double value_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_NUMBER_LITERAL_TYPE_H */
diff --git a/es2panda/typescript/types/numberType.cpp b/es2panda/typescript/types/numberType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90e0757c6c0689fb4149531278818db9de80dedf
--- /dev/null
+++ b/es2panda/typescript/types/numberType.cpp
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "numberType.h"
+
+#include <binder/variable.h>
+#include <typescript/types/enumType.h>
+
+namespace panda::es2panda::checker {
+
+NumberType::NumberType() : Type(TypeFlag::NUMBER) {}
+
+void NumberType::ToString(std::stringstream &ss) const
+{
+    ss << "number";
+}
+
+void NumberType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsNumberType()) {
+        relation->Result(true);
+    }
+}
+
+void NumberType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsNumberLiteralType()) {
+        relation->Result(true);
+    } else if (source->IsEnumType()) {
+        const EnumType *sourceEnumType = source->AsEnumType();
+        const binder::EnumVariable *enumVar = sourceEnumType->EnumVar();
+
+        if (std::holds_alternative<double>(enumVar->Value())) {
+            relation->Result(true);
+        }
+    }
+}
+
+TypeFacts NumberType::GetTypeFacts() const
+{
+    return TypeFacts::NUMBER_FACTS;
+}
+
+Type *NumberType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                              [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/numberType.h b/es2panda/typescript/types/numberType.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c9d58cad4521738fe5da7969ef3a41a7a2be53f
--- /dev/null
+++ b/es2panda/typescript/types/numberType.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NUMBER_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_NUMBER_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class NumberType : public Type {
+public:
+    NumberType();
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_NUMBER_TYPE_H */
diff --git a/es2panda/typescript/types/objectDescriptor.cpp b/es2panda/typescript/types/objectDescriptor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c1d6004295578c1b7beb323a6dbbbd6c13ab985
--- /dev/null
+++ b/es2panda/typescript/types/objectDescriptor.cpp
@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "objectDescriptor.h"
+
+#include <binder/variable.h>
+#include <typescript/types/indexInfo.h>
+#include <typescript/types/signature.h>
+
+namespace panda::es2panda::checker {
+
+binder::LocalVariable *ObjectDescriptor::FindProperty(const util::StringView &name) const
+{
+    for (auto *it : properties) {
+        if (it->Name() == name) {
+            return it;
+        }
+    }
+
+    return nullptr;
+}
+
+ObjectDescriptor::~ObjectDescriptor()
+{
+    for (auto *it : properties) {
+        delete it;
+    }
+
+    for (auto *it : callSignatures) {
+        delete it;
+    }
+
+    for (auto *it : constructSignatures) {
+        delete it;
+    }
+
+    delete stringIndexInfo;
+    delete numberIndexInfo;
+}
+
+void ObjectDescriptor::Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation,
+                            GlobalTypesHolder *globalTypes)
+{
+    // kézzel másolás
+    for (auto *it : properties) {
+        auto *copiedProp = it->Copy(allocator, it->Declaration());
+        copiedProp->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes));
+        copiedDesc->properties.push_back(copiedProp);
+    }
+
+    for (auto *it : callSignatures) {
+        copiedDesc->callSignatures.push_back(it->Copy(allocator, relation, globalTypes));
+    }
+
+    for (auto *it : constructSignatures) {
+        copiedDesc->constructSignatures.push_back(it->Copy(allocator, relation, globalTypes));
+    }
+
+    if (numberIndexInfo) {
+        copiedDesc->numberIndexInfo = numberIndexInfo->Copy(allocator, relation, globalTypes);
+    }
+
+    if (stringIndexInfo) {
+        copiedDesc->stringIndexInfo = stringIndexInfo->Copy(allocator, relation, globalTypes);
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/objectDescriptor.h b/es2panda/typescript/types/objectDescriptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ac489f8c703b994b68d17f9a20c1c8aa0c2e9ca
--- /dev/null
+++ b/es2panda/typescript/types/objectDescriptor.h
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_OBJECT_DESCRIPTOR_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_OBJECT_DESCRIPTOR_H
+
+#include <macros.h>
+#include <util/ustring.h>
+#include <vector>
+
+namespace panda::es2panda::binder {
+class LocalVariable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::checker {
+
+class Signature;
+class IndexInfo;
+class Type;
+class TypeRelation;
+class GlobalTypesHolder;
+
+class ObjectDescriptor {
+public:
+    ObjectDescriptor() = default;
+    ~ObjectDescriptor();
+    NO_COPY_SEMANTIC(ObjectDescriptor);
+    NO_MOVE_SEMANTIC(ObjectDescriptor);
+
+    binder::LocalVariable *FindProperty(const util::StringView &name) const;
+    void Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation,
+              GlobalTypesHolder *globalTypes);
+
+    std::vector<binder::LocalVariable *> properties {};
+    std::vector<Signature *> callSignatures {};
+    std::vector<Signature *> constructSignatures {};
+    IndexInfo *stringIndexInfo {nullptr};
+    IndexInfo *numberIndexInfo {nullptr};
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_OBJECT_DESCRIPTOR_H */
diff --git a/es2panda/typescript/types/objectLiteralType.cpp b/es2panda/typescript/types/objectLiteralType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ccdd18d6f757ceb68d439d67b286c1f46752363d
--- /dev/null
+++ b/es2panda/typescript/types/objectLiteralType.cpp
@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "objectLiteralType.h"
+
+#include <binder/variable.h>
+#include <typescript/types/indexInfo.h>
+#include <typescript/types/signature.h>
+
+namespace panda::es2panda::checker {
+
+class Checker;
+
+ObjectLiteralType::ObjectLiteralType(ObjectDescriptor *desc) : ObjectType(ObjectType::ObjectTypeKind::LITERAL, desc) {}
+ObjectLiteralType::ObjectLiteralType() : ObjectType(ObjectType::ObjectTypeKind::LITERAL) {}
+
+void ObjectLiteralType::ToString(std::stringstream &ss) const
+{
+    ss << "{ ";
+
+    if (desc_->stringIndexInfo) {
+        desc_->stringIndexInfo->ToString(ss, false);
+        ss << "; ";
+    }
+
+    if (desc_->numberIndexInfo) {
+        desc_->numberIndexInfo->ToString(ss, true);
+        ss << "; ";
+    }
+
+    for (auto *it : desc_->callSignatures) {
+        it->ToString(ss, nullptr, true);
+        ss << "; ";
+    }
+
+    for (auto *it : desc_->constructSignatures) {
+        ss << "new ";
+        it->ToString(ss, nullptr, true);
+        ss << "; ";
+    }
+
+    for (auto *it : desc_->properties) {
+        if (it->HasFlag(binder::VariableFlags::READONLY)) {
+            ss << "readonly ";
+        }
+        ss << it->Name();
+
+        if (it->HasFlag(binder::VariableFlags::OPTIONAL)) {
+            ss << "?";
+        }
+        if (it->HasFlag(binder::VariableFlags::PROPERTY)) {
+            ss << ": ";
+        }
+        it->TsType()->ToString(ss);
+        ss << "; ";
+    }
+
+    ss << "}";
+}
+
+TypeFacts ObjectLiteralType::GetTypeFacts() const
+{
+    if (desc_->properties.empty() && desc_->callSignatures.empty() && desc_->constructSignatures.empty() &&
+        !desc_->numberIndexInfo && !desc_->stringIndexInfo) {
+        return TypeFacts::EMPTY_OBJECT_FACTS;
+    }
+
+    return TypeFacts::OBJECT_FACTS;
+}
+
+Type *ObjectLiteralType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    ObjectDescriptor *copiedDesc = allocator->New<ObjectDescriptor>();
+    desc_->Copy(allocator, copiedDesc, relation, globalTypes);
+    return allocator->New<ObjectLiteralType>(copiedDesc);
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/objectLiteralType.h b/es2panda/typescript/types/objectLiteralType.h
new file mode 100644
index 0000000000000000000000000000000000000000..640aacaf7c008effc9024a5d29a30617c5ce5ef9
--- /dev/null
+++ b/es2panda/typescript/types/objectLiteralType.h
@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_OBJECT_LITERAL_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_OBJECT_LITERAL_TYPE_H
+
+#include "objectType.h"
+
+namespace panda::es2panda::checker {
+
+class ObjectLiteralType : public ObjectType {
+public:
+    explicit ObjectLiteralType(ObjectDescriptor *desc);
+    ObjectLiteralType();
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_OBJECT_LITERAL_TYPE_H */
diff --git a/es2panda/typescript/types/objectType.cpp b/es2panda/typescript/types/objectType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f70167b2342b622e8f7ae266daaa184ca61c894d
--- /dev/null
+++ b/es2panda/typescript/types/objectType.cpp
@@ -0,0 +1,368 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "objectType.h"
+
+#include <algorithm>
+#include <binder/variable.h>
+#include <typescript/types/indexInfo.h>
+#include <typescript/types/interfaceType.h>
+#include <typescript/types/signature.h>
+
+namespace panda::es2panda::checker {
+
+ObjectType::ObjectType(ObjectTypeKind kind)
+    : Type(TypeFlag::OBJECT), kind_(kind), desc_(nullptr), objFlag_(ObjectFlags::CHECK_EXCESS_PROPS)
+{
+}
+
+ObjectType::ObjectType(ObjectTypeKind kind, ObjectDescriptor *desc)
+    : Type(TypeFlag::OBJECT), kind_(kind), desc_(desc), objFlag_(ObjectFlags::CHECK_EXCESS_PROPS)
+{
+}
+
+ObjectType::ObjectTypeKind ObjectType::Kind() const
+{
+    return kind_;
+}
+
+std::vector<Signature *> &ObjectType::CallSignatures()
+{
+    return desc_->callSignatures;
+}
+
+const std::vector<Signature *> &ObjectType::CallSignatures() const
+{
+    return desc_->callSignatures;
+}
+
+const std::vector<Signature *> &ObjectType::ConstructSignatures() const
+{
+    return desc_->constructSignatures;
+}
+
+const IndexInfo *ObjectType::StringIndexInfo() const
+{
+    return desc_->stringIndexInfo;
+}
+
+const IndexInfo *ObjectType::NumberIndexInfo() const
+{
+    return desc_->numberIndexInfo;
+}
+
+IndexInfo *ObjectType::StringIndexInfo()
+{
+    return desc_->stringIndexInfo;
+}
+
+IndexInfo *ObjectType::NumberIndexInfo()
+{
+    return desc_->numberIndexInfo;
+}
+
+const std::vector<binder::LocalVariable *> &ObjectType::Properties() const
+{
+    return desc_->properties;
+}
+
+ObjectDescriptor *ObjectType::Desc()
+{
+    return desc_;
+}
+
+const ObjectDescriptor *ObjectType::Desc() const
+{
+    return desc_;
+}
+
+void ObjectType::AddProperty(binder::LocalVariable *prop)
+{
+    desc_->properties.push_back(prop);
+}
+
+binder::LocalVariable *ObjectType::GetProperty(const util::StringView &name) const
+{
+    for (auto *it : desc_->properties) {
+        if (name == it->Name()) {
+            return it;
+        }
+    }
+
+    return nullptr;
+}
+
+void ObjectType::AddSignature(Signature *signature, bool isCall)
+{
+    if (isCall) {
+        desc_->callSignatures.push_back(signature);
+    } else {
+        desc_->constructSignatures.push_back(signature);
+    }
+}
+
+void ObjectType::AddObjectFlag(ObjectFlags flag)
+{
+    objFlag_ |= flag;
+}
+
+void ObjectType::RemoveObjectFlag(ObjectFlags flag)
+{
+    objFlag_ &= ~flag;
+}
+
+bool ObjectType::HasObjectFlag(ObjectFlags flag) const
+{
+    return (objFlag_ & flag) != 0;
+}
+
+bool ObjectType::EachSignatureRelatedToSomeSignature(TypeRelation *relation,
+                                                     const std::vector<Signature *> &sourceSignatures,
+                                                     const std::vector<Signature *> &targetSignatures)
+{
+    std::vector<Signature *> targetCopy = targetSignatures;
+
+    return std::all_of(sourceSignatures.begin(), sourceSignatures.end(),
+                       [relation, &targetCopy](const Signature *source) {
+                           return SignatureRelatedToSomeSignature(relation, source, &targetCopy);
+                       });
+}
+
+bool ObjectType::SignatureRelatedToSomeSignature(TypeRelation *relation, const Signature *sourceSignature,
+                                                 std::vector<Signature *> *targetSignatures)
+{
+    for (auto it = targetSignatures->begin(); it != targetSignatures->end();) {
+        if (relation->IsIdenticalTo(sourceSignature, *it)) {
+            targetSignatures->erase(it);
+            return true;
+        }
+
+        it++;
+    }
+
+    return false;
+}
+
+void ObjectType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (!other->IsObjectType() || kind_ != other->AsObjectType()->Kind()) {
+        return;
+    }
+
+    const ObjectType *otherObj = other->AsObjectType();
+
+    if (desc_->properties.size() != otherObj->Properties().size() ||
+        CallSignatures().size() != otherObj->CallSignatures().size() ||
+        ConstructSignatures().size() != otherObj->ConstructSignatures().size() ||
+        (desc_->numberIndexInfo && !otherObj->NumberIndexInfo()) ||
+        (!desc_->numberIndexInfo && otherObj->NumberIndexInfo()) ||
+        (desc_->stringIndexInfo && !otherObj->StringIndexInfo()) ||
+        (!desc_->stringIndexInfo && otherObj->StringIndexInfo())) {
+        relation->Result(false);
+        return;
+    }
+
+    for (auto *it : desc_->properties) {
+        binder::LocalVariable *found = otherObj->Desc()->FindProperty(it->Name());
+        if (!found) {
+            relation->Result(false);
+            return;
+        }
+
+        relation->IsIdenticalTo(it->TsType(), found->TsType());
+
+        if (!relation->IsTrue()) {
+            return;
+        }
+
+        if (it->Flags() != found->Flags()) {
+            relation->Result(false);
+            return;
+        }
+    }
+
+    if (!EachSignatureRelatedToSomeSignature(relation, CallSignatures(), otherObj->CallSignatures()) ||
+        !EachSignatureRelatedToSomeSignature(relation, otherObj->CallSignatures(), CallSignatures())) {
+        return;
+    }
+
+    if (!EachSignatureRelatedToSomeSignature(relation, ConstructSignatures(), otherObj->ConstructSignatures()) ||
+        !EachSignatureRelatedToSomeSignature(relation, otherObj->ConstructSignatures(), ConstructSignatures())) {
+        return;
+    }
+
+    if (desc_->numberIndexInfo) {
+        relation->IsIdenticalTo(desc_->numberIndexInfo, otherObj->NumberIndexInfo());
+        if (!relation->IsTrue()) {
+            return;
+        }
+    }
+
+    if (desc_->stringIndexInfo) {
+        relation->IsIdenticalTo(desc_->stringIndexInfo, otherObj->StringIndexInfo());
+        if (!relation->IsTrue()) {
+            return;
+        }
+    }
+}
+
+void ObjectType::AssignProperties(TypeRelation *relation, const ObjectType *source,
+                                  bool performExcessPropertyCheck) const
+{
+    std::vector<binder::LocalVariable *> targetProperties;
+    const IndexInfo *numberInfo = nullptr;
+    const IndexInfo *stringInfo = nullptr;
+
+    if (this->IsInterfaceType()) {
+        this->AsInterfaceType()->CollectProperties(&targetProperties);
+        numberInfo = this->AsInterfaceType()->FindIndexInfo(true);
+        stringInfo = this->AsInterfaceType()->FindIndexInfo(false);
+    } else {
+        targetProperties = desc_->properties;
+        numberInfo = desc_->numberIndexInfo;
+        stringInfo = desc_->stringIndexInfo;
+    }
+
+    for (auto *it : targetProperties) {
+        binder::LocalVariable *found = source->GetProperty(it->Name());
+
+        if (found) {
+            if (found->TsType()->HasTypeFlag(TypeFlag::RELATION_CHECKED)) {
+                found->TsType()->RemoveTypeFlag(TypeFlag::RELATION_CHECKED);
+                continue;
+            }
+
+            if (!relation->IsAssignableTo(found->TsType(), it->TsType())) {
+                return;
+            }
+
+            if (performExcessPropertyCheck && found->HasFlag(binder::VariableFlags::OPTIONAL) &&
+                !it->HasFlag(binder::VariableFlags::OPTIONAL)) {
+                relation->Result(false);
+                return;
+            }
+
+            continue;
+        }
+
+        if (numberInfo && it->HasFlag(binder::VariableFlags::COMPUTED_INDEX) &&
+            !relation->IsAssignableTo(numberInfo->InfoType(), it->TsType())) {
+            return;
+        }
+
+        if (stringInfo && !relation->IsAssignableTo(stringInfo->InfoType(), it->TsType())) {
+            return;
+        }
+
+        if (!performExcessPropertyCheck) {
+            continue;
+        }
+
+        if (!it->HasFlag(binder::VariableFlags::OPTIONAL)) {
+            relation->Result(false);
+            return;
+        }
+    }
+}
+
+void ObjectType::AssignSignatures(TypeRelation *relation, const ObjectType *source, bool assignCallSignatures) const
+{
+    std::vector<Signature *> targetSignatures;
+    std::vector<Signature *> sourceSignatures;
+
+    if (this->IsInterfaceType()) {
+        this->AsInterfaceType()->CollectSignatures(&targetSignatures, assignCallSignatures);
+    } else {
+        targetSignatures = assignCallSignatures ? CallSignatures() : ConstructSignatures();
+    }
+
+    if (source->IsInterfaceType()) {
+        source->AsInterfaceType()->CollectSignatures(&sourceSignatures, assignCallSignatures);
+    } else {
+        sourceSignatures = assignCallSignatures ? source->CallSignatures() : source->ConstructSignatures();
+    }
+
+    for (auto *targetSignature : targetSignatures) {
+        bool foundCompatible = false;
+        for (auto *sourceSignature : sourceSignatures) {
+            targetSignature->AssignmentTarget(relation, sourceSignature);
+
+            if (relation->IsTrue()) {
+                foundCompatible = true;
+                break;
+            }
+        }
+
+        if (!foundCompatible) {
+            relation->Result(false);
+            return;
+        }
+    }
+}
+
+void ObjectType::AssignIndexInfo([[maybe_unused]] TypeRelation *relation, const ObjectType *source,
+                                 bool assignNumberInfo) const
+{
+    const IndexInfo *targetInfo = nullptr;
+    const IndexInfo *sourceInfo = nullptr;
+
+    if (this->IsInterfaceType()) {
+        targetInfo = this->AsInterfaceType()->FindIndexInfo(assignNumberInfo);
+    } else {
+        targetInfo = assignNumberInfo ? NumberIndexInfo() : StringIndexInfo();
+    }
+
+    if (source->IsInterfaceType()) {
+        sourceInfo = source->AsInterfaceType()->FindIndexInfo(assignNumberInfo);
+    } else {
+        sourceInfo = assignNumberInfo ? source->NumberIndexInfo() : source->StringIndexInfo();
+    }
+
+    if (targetInfo && sourceInfo) {
+        targetInfo->AssignmentTarget(relation, sourceInfo);
+    }
+}
+
+void ObjectType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (!source->IsObjectType()) {
+        relation->Result(false);
+        return;
+    }
+
+    relation->Result(true);
+
+    const ObjectType *sourceObj = source->AsObjectType();
+
+    AssignProperties(relation, sourceObj, HasObjectFlag(ObjectFlags::CHECK_EXCESS_PROPS));
+
+    if (relation->IsTrue()) {
+        AssignSignatures(relation, sourceObj);
+
+        if (relation->IsTrue()) {
+            AssignSignatures(relation, sourceObj, false);
+
+            if (relation->IsTrue()) {
+                AssignIndexInfo(relation, sourceObj);
+
+                if (relation->IsTrue()) {
+                    AssignIndexInfo(relation, sourceObj, false);
+                }
+            }
+        }
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/objectType.h b/es2panda/typescript/types/objectType.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8ab9c9aa75964f0bdc0741454a1f19c36240309
--- /dev/null
+++ b/es2panda/typescript/types/objectType.h
@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_OBJECT_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_OBJECT_TYPE_H
+
+#include "type.h"
+
+#include <typescript/types/objectDescriptor.h>
+
+#include <util/ustring.h>
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::binder {
+class LocalVariable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::checker {
+
+class Signature;
+class IndexInfo;
+
+#define DECLARE_OBJECT_TYPENAMES(objectKind, typeName) class typeName;
+OBJECT_TYPE_MAPPING(DECLARE_OBJECT_TYPENAMES)
+#undef DECLARE_OBJECT_TYPENAMES
+
+class ObjectType : public Type {
+public:
+    enum class ObjectTypeKind {
+        LITERAL,
+        CLASS,
+        INTERFACE,
+        TUPLE,
+        FUNCTION,
+    };
+
+    enum class ObjectFlags {
+        NO_OPTS = 0,
+        CHECK_EXCESS_PROPS = 1 << 0,
+        HAVE_REST = 1 << 1,
+    };
+
+#define OBJECT_TYPE_IS_CHECKS(objectKind, typeName) \
+    bool Is##typeName() const                       \
+    {                                               \
+        return kind_ == objectKind;                 \
+    }
+    OBJECT_TYPE_MAPPING(OBJECT_TYPE_IS_CHECKS)
+#undef OBJECT_TYPE_IS_CHECKS
+
+#define OBJECT_TYPE_AS_CASTS(objectKind, typeName)       \
+    typeName *As##typeName()                             \
+    {                                                    \
+        ASSERT(Is##typeName());                          \
+        return reinterpret_cast<typeName *>(this);       \
+    }                                                    \
+    const typeName *As##typeName() const                 \
+    {                                                    \
+        ASSERT(Is##typeName());                          \
+        return reinterpret_cast<const typeName *>(this); \
+    }
+    OBJECT_TYPE_MAPPING(OBJECT_TYPE_AS_CASTS)
+#undef OBJECT_TYPE_AS_CASTS
+
+    explicit ObjectType(ObjectTypeKind kind);
+    ObjectType(ObjectTypeKind kind, ObjectDescriptor *desc);
+
+    ObjectTypeKind Kind() const;
+    std::vector<Signature *> &CallSignatures();
+    const std::vector<Signature *> &CallSignatures() const;
+    const std::vector<Signature *> &ConstructSignatures() const;
+    const IndexInfo *StringIndexInfo() const;
+    const IndexInfo *NumberIndexInfo() const;
+    IndexInfo *StringIndexInfo();
+    IndexInfo *NumberIndexInfo();
+    const std::vector<binder::LocalVariable *> &Properties() const;
+    ObjectDescriptor *Desc();
+    const ObjectDescriptor *Desc() const;
+
+    void AddProperty(binder::LocalVariable *prop);
+    void AddSignature(Signature *signature, bool isCall = true);
+    void AddObjectFlag(ObjectFlags flag);
+    void RemoveObjectFlag(ObjectFlags flag);
+    bool HasObjectFlag(ObjectFlags flag) const;
+
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    virtual binder::LocalVariable *GetProperty(const util::StringView &name) const;
+
+    static bool SignatureRelatedToSomeSignature(TypeRelation *relation, const Signature *sourceSignature,
+                                                std::vector<Signature *> *targetSignatures);
+    static bool EachSignatureRelatedToSomeSignature(TypeRelation *relation,
+                                                    const std::vector<Signature *> &sourceSignatures,
+                                                    const std::vector<Signature *> &targetSignatures);
+
+    void AssignProperties(TypeRelation *relation, const ObjectType *source,
+                          bool performExcessPropertyCheck = false) const;
+    void AssignSignatures(TypeRelation *relation, const ObjectType *source, bool assignCallSignatures = true) const;
+    void AssignIndexInfo(TypeRelation *relation, const ObjectType *source, bool assignNumberInfo = true) const;
+
+protected:
+    ObjectTypeKind kind_;
+    ObjectDescriptor *desc_;
+    ObjectFlags objFlag_;
+};
+
+DEFINE_BITOPS(ObjectType::ObjectFlags)
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_OBJECT_TYPE_H */
diff --git a/es2panda/typescript/types/signature.cpp b/es2panda/typescript/types/signature.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2d0568c9bbcdcb21f16b0c5da5956c157527a46d
--- /dev/null
+++ b/es2panda/typescript/types/signature.cpp
@@ -0,0 +1,199 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "signature.h"
+
+#include <binder/variable.h>
+
+namespace panda::es2panda::checker {
+
+SignatureInfo::SignatureInfo(const SignatureInfo *other, ArenaAllocator *allocator)
+{
+    for (auto *it : other->funcParams) {
+        funcParams.push_back(it->Copy(allocator, it->Declaration()));
+    }
+
+    minArgCount = other->minArgCount;
+
+    if (other->restVar) {
+        restVar = other->restVar->Copy(allocator, other->restVar->Declaration());
+    }
+}
+
+Signature::Signature(SignatureInfo *signatureInfo, Type *returnType)
+    : signatureInfo_(signatureInfo), returnType_(returnType)
+{
+}
+
+const SignatureInfo *Signature::Info() const
+{
+    return signatureInfo_;
+}
+
+const std::vector<binder::LocalVariable *> &Signature::Params() const
+{
+    return signatureInfo_->funcParams;
+}
+
+const Type *Signature::ReturnType() const
+{
+    return returnType_;
+}
+
+Type *Signature::ReturnType()
+{
+    return returnType_;
+}
+
+uint32_t Signature::MinArgCount() const
+{
+    return signatureInfo_->minArgCount;
+}
+
+uint32_t Signature::OptionalArgCount() const
+{
+    return signatureInfo_->funcParams.size() - signatureInfo_->minArgCount;
+}
+
+void Signature::SetReturnType(Type *type)
+{
+    returnType_ = type;
+}
+
+const binder::LocalVariable *Signature::RestVar() const
+{
+    return signatureInfo_->restVar;
+}
+
+Signature *Signature::Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    SignatureInfo *copiedInfo = allocator->New<checker::SignatureInfo>(signatureInfo_, allocator);
+
+    for (auto *it : copiedInfo->funcParams) {
+        it->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes));
+    }
+
+    Type *copiedReturnType = returnType_->Instantiate(allocator, relation, globalTypes);
+
+    return allocator->New<Signature>(copiedInfo, copiedReturnType);
+}
+
+void Signature::ToString(std::stringstream &ss, const binder::Variable *variable, bool printAsMethod) const
+{
+    ss << "(";
+
+    for (auto it = signatureInfo_->funcParams.begin(); it != signatureInfo_->funcParams.end(); it++) {
+        ss << (*it)->Name();
+
+        if ((*it)->HasFlag(binder::VariableFlags::OPTIONAL)) {
+            ss << "?";
+        }
+
+        ss << ": ";
+
+        (*it)->TsType()->ToString(ss);
+
+        if (std::next(it) != signatureInfo_->funcParams.end()) {
+            ss << ", ";
+        }
+    }
+
+    if (signatureInfo_->restVar) {
+        if (!signatureInfo_->funcParams.empty()) {
+            ss << ", ";
+        }
+
+        ss << "...";
+        ss << signatureInfo_->restVar->Name();
+        ss << ": ";
+        signatureInfo_->restVar->TsType()->ToString(ss);
+        ss << "[]";
+    }
+
+    ss << ")";
+
+    if (printAsMethod || (variable && variable->HasFlag(binder::VariableFlags::METHOD))) {
+        ss << ": ";
+    } else {
+        ss << " => ";
+    }
+
+    returnType_->ToString(ss);
+}
+
+void Signature::Identical(TypeRelation *relation, const Signature *other) const
+{
+    if (signatureInfo_->minArgCount != other->MinArgCount() ||
+        signatureInfo_->funcParams.size() != other->Params().size()) {
+        relation->Result(false);
+        return;
+    }
+
+    relation->IsIdenticalTo(returnType_, other->ReturnType());
+
+    if (relation->IsTrue()) {
+        for (uint64_t i = 0; i < signatureInfo_->funcParams.size(); i++) {
+            relation->IsIdenticalTo(signatureInfo_->funcParams[i]->TsType(), other->Params()[i]->TsType());
+            if (!relation->IsTrue()) {
+                return;
+            }
+        }
+
+        if (signatureInfo_->restVar && other->RestVar()) {
+            relation->IsIdenticalTo(signatureInfo_->restVar->TsType(), other->RestVar()->TsType());
+        } else if ((signatureInfo_->restVar && !other->RestVar()) || (!signatureInfo_->restVar && other->RestVar())) {
+            relation->Result(false);
+        }
+    }
+}
+
+void Signature::AssignmentTarget(TypeRelation *relation, const Signature *source) const
+{
+    if (!signatureInfo_->restVar &&
+        (source->Params().size() - source->OptionalArgCount()) > signatureInfo_->funcParams.size()) {
+        relation->Result(false);
+        return;
+    }
+
+    for (size_t i = 0; i < source->Params().size(); i++) {
+        if (!signatureInfo_->restVar && i >= Params().size()) {
+            break;
+        }
+
+        if (signatureInfo_->restVar) {
+            relation->IsAssignableTo(source->Params()[i]->TsType(), signatureInfo_->restVar->TsType());
+
+            if (!relation->IsTrue()) {
+                return;
+            }
+
+            continue;
+        }
+
+        relation->IsAssignableTo(source->Params()[i]->TsType(), Params()[i]->TsType());
+
+        if (!relation->IsTrue()) {
+            return;
+        }
+    }
+
+    relation->IsAssignableTo(source->ReturnType(), ReturnType());
+
+    if (relation->IsTrue() && signatureInfo_->restVar && source->RestVar()) {
+        relation->IsAssignableTo(source->RestVar()->TsType(), signatureInfo_->restVar->TsType());
+    }
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/signature.h b/es2panda/typescript/types/signature.h
new file mode 100644
index 0000000000000000000000000000000000000000..5943e59311880519ff2dedc57c9e2a525c0d4429
--- /dev/null
+++ b/es2panda/typescript/types/signature.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_SIGNATURE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_SIGNATURE_H
+
+#include "type.h"
+
+namespace panda::es2panda::binder {
+class LocalVariable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::checker {
+
+class SignatureInfo {
+public:
+    SignatureInfo() = default;
+    explicit SignatureInfo(const SignatureInfo *other, ArenaAllocator *allocator);
+    NO_COPY_SEMANTIC(SignatureInfo);
+    NO_MOVE_SEMANTIC(SignatureInfo);
+    ~SignatureInfo() = default;
+
+    uint32_t minArgCount {};
+    binder::LocalVariable *restVar {};
+    std::vector<binder::LocalVariable *> funcParams {};
+};
+
+class Signature {
+public:
+    Signature(SignatureInfo *signatureInfo, Type *returnType);
+    ~Signature() = default;
+    NO_COPY_SEMANTIC(Signature);
+    NO_MOVE_SEMANTIC(Signature);
+
+    const SignatureInfo *Info() const;
+    const std::vector<binder::LocalVariable *> &Params() const;
+    const Type *ReturnType() const;
+    Type *ReturnType();
+    uint32_t MinArgCount() const;
+    uint32_t OptionalArgCount() const;
+    void SetReturnType(Type *type);
+    const binder::LocalVariable *RestVar() const;
+    Signature *Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes);
+
+    void ToString(std::stringstream &ss, const binder::Variable *variable, bool printAsMethod = false) const;
+    void Identical(TypeRelation *relation, const Signature *other) const;
+    void AssignmentTarget(TypeRelation *relation, const Signature *source) const;
+
+private:
+    SignatureInfo *signatureInfo_;
+    Type *returnType_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_SIGNATURE_H */
diff --git a/es2panda/typescript/types/stringLiteralType.cpp b/es2panda/typescript/types/stringLiteralType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..084f00749f26623eac7db504a8751ec18089d809
--- /dev/null
+++ b/es2panda/typescript/types/stringLiteralType.cpp
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stringLiteralType.h"
+
+namespace panda::es2panda::checker {
+
+StringLiteralType::StringLiteralType(util::StringView value) : Type(TypeFlag::STRING_LITERAL), value_(value) {}
+
+const util::StringView &StringLiteralType::Value() const
+{
+    return value_;
+}
+
+void StringLiteralType::ToString(std::stringstream &ss) const
+{
+    ss << "\"" << value_ << "\"";
+}
+
+void StringLiteralType::ToStringAsSrc(std::stringstream &ss) const
+{
+    ss << "string";
+}
+
+void StringLiteralType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsStringLiteralType()) {
+        relation->Result(value_ == other->AsStringLiteralType()->Value());
+    }
+}
+
+void StringLiteralType::AssignmentTarget([[maybe_unused]] TypeRelation *relation,
+                                         [[maybe_unused]] const Type *source) const
+{
+}
+
+TypeFacts StringLiteralType::GetTypeFacts() const
+{
+    return value_.Empty() ? TypeFacts::EMPTY_STRING_FACTS : TypeFacts::NON_EMPTY_STRING_FACTS;
+}
+
+Type *StringLiteralType::Instantiate([[maybe_unused]] ArenaAllocator *allocator,
+                                     [[maybe_unused]] TypeRelation *relation,
+                                     [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/stringLiteralType.h b/es2panda/typescript/types/stringLiteralType.h
new file mode 100644
index 0000000000000000000000000000000000000000..f289cc68fde2136bab58ae44d2a802f0918a5aa2
--- /dev/null
+++ b/es2panda/typescript/types/stringLiteralType.h
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_STRING_LITERAL_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_STRING_LITERAL_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class StringLiteralType : public Type {
+public:
+    explicit StringLiteralType(util::StringView value);
+
+    const util::StringView &Value() const;
+    void ToString(std::stringstream &ss) const override;
+    void ToStringAsSrc(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    util::StringView value_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_STRING_LITERAL_TYPE_H */
diff --git a/es2panda/typescript/types/stringType.cpp b/es2panda/typescript/types/stringType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0da06419224e848f90cd65985d41e6662a5a99a3
--- /dev/null
+++ b/es2panda/typescript/types/stringType.cpp
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stringType.h"
+
+namespace panda::es2panda::checker {
+
+StringType::StringType() : Type(TypeFlag::STRING) {}
+
+void StringType::ToString(std::stringstream &ss) const
+{
+    ss << "string";
+}
+
+void StringType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsStringType()) {
+        relation->Result(true);
+    }
+}
+
+void StringType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (source->IsStringLiteralType()) {
+        relation->Result(true);
+    }
+}
+
+TypeFacts StringType::GetTypeFacts() const
+{
+    return TypeFacts::STRING_FACTS;
+}
+
+Type *StringType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                              [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/stringType.h b/es2panda/typescript/types/stringType.h
new file mode 100644
index 0000000000000000000000000000000000000000..e8e995a95acbf0e8edac70b198709d78102ea7f7
--- /dev/null
+++ b/es2panda/typescript/types/stringType.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_STRING_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_STRING_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class StringType : public Type {
+public:
+    StringType();
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_STRING_TYPE_H */
diff --git a/es2panda/typescript/types/tupleType.cpp b/es2panda/typescript/types/tupleType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58b4acc91f0d964ed04c7bd478121063b5acd5b2
--- /dev/null
+++ b/es2panda/typescript/types/tupleType.cpp
@@ -0,0 +1,282 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tupleType.h"
+
+#include <binder/variable.h>
+
+namespace panda::es2panda::checker {
+
+TupleTypeIterator::TupleTypeIterator(TupleType *tuple) : tupleType_(tuple), iter_(0) {}
+
+Type *TupleTypeIterator::Next()
+{
+    if (iter_ >= tupleType_->Properties().size()) {
+        return nullptr;
+    }
+
+    Type *returnType = tupleType_->Properties()[iter_]->TsType();
+
+    iter_++;
+
+    return returnType;
+}
+
+Type *TupleTypeIterator::Current()
+{
+    if (iter_ >= tupleType_->Properties().size()) {
+        return nullptr;
+    }
+
+    return tupleType_->Properties()[iter_]->TsType();
+}
+
+uint32_t TupleTypeIterator::Iter() const
+{
+    return iter_;
+}
+
+TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                     uint32_t minLength, uint32_t fixedLength, bool readonly)
+    : ObjectType(ObjectType::ObjectTypeKind::TUPLE, desc),
+      elementFlags_(std::move(elementFlags)),
+      combinedFlags_(combinedFlags),
+      minLength_(minLength),
+      fixedLength_(fixedLength),
+      readonly_(readonly)
+{
+    if (readonly_) {
+        for (auto *it : Properties()) {
+            it->AddFlag(binder::VariableFlags::READONLY);
+        }
+    }
+
+    iterator_ = new TupleTypeIterator(this);
+}
+
+TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                     uint32_t minLength, uint32_t fixedLength, bool readonly, NamedTupleMemberPool &&namedMembers)
+    : ObjectType(ObjectType::ObjectTypeKind::TUPLE, desc),
+      elementFlags_(std::move(elementFlags)),
+      combinedFlags_(combinedFlags),
+      minLength_(minLength),
+      fixedLength_(fixedLength),
+      namedMembers_(std::move(namedMembers)),
+      readonly_(readonly)
+{
+    if (readonly_) {
+        for (auto *it : Properties()) {
+            it->AddFlag(binder::VariableFlags::READONLY);
+        }
+    }
+
+    iterator_ = new TupleTypeIterator(this);
+}
+
+TupleType::TupleType() : ObjectType(ObjectType::ObjectTypeKind::TUPLE) {}
+
+TupleType::~TupleType()
+{
+    delete iterator_;
+}
+
+ElementFlags TupleType::CombinedFlags() const
+{
+    return combinedFlags_;
+}
+
+uint32_t TupleType::MinLength() const
+{
+    return minLength_;
+}
+
+uint32_t TupleType::FixedLength() const
+{
+    return fixedLength_;
+}
+
+ElementFlags TupleType::GetElementFlag(const util::StringView &index) const
+{
+    auto res = elementFlags_.find(index);
+    if (res != elementFlags_.end()) {
+        return res->second;
+    }
+    return ElementFlags::NO_OPTS;
+}
+
+bool TupleType::HasCombinedFlag(ElementFlags combinedFlag) const
+{
+    return (combinedFlags_ & combinedFlag) != 0;
+}
+
+bool TupleType::IsReadOnly() const
+{
+    return readonly_;
+}
+
+TupleTypeIterator *TupleType::Iterator()
+{
+    return iterator_;
+}
+
+const TupleTypeIterator *TupleType::Iterator() const
+{
+    return iterator_;
+}
+
+const NamedTupleMemberPool &TupleType::NamedMembers() const
+{
+    return namedMembers_;
+}
+
+const util::StringView &TupleType::FindNamedMemberName(binder::LocalVariable *member) const
+{
+    auto res = namedMembers_.find(member);
+    return res->second;
+}
+
+void TupleType::ToString(std::stringstream &ss) const
+{
+    if (readonly_) {
+        ss << "readonly ";
+    }
+    ss << "[";
+
+    if (namedMembers_.empty()) {
+        for (auto it = desc_->properties.begin(); it != desc_->properties.end(); it++) {
+            (*it)->TsType()->ToString(ss);
+            if ((*it)->HasFlag(binder::VariableFlags::OPTIONAL)) {
+                ss << "?";
+            }
+
+            if (std::next(it) != desc_->properties.end()) {
+                ss << ", ";
+            }
+        }
+    } else {
+        for (auto it = desc_->properties.begin(); it != desc_->properties.end(); it++) {
+            const util::StringView &memberName = FindNamedMemberName(*it);
+            ss << memberName;
+
+            if ((*it)->HasFlag(binder::VariableFlags::OPTIONAL)) {
+                ss << "?";
+            }
+
+            ss << ": ";
+            (*it)->TsType()->ToString(ss);
+            if (std::next(it) != desc_->properties.end()) {
+                ss << ", ";
+            }
+        }
+    }
+
+    ss << "]";
+}
+
+void TupleType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsObjectType() && other->AsObjectType()->IsTupleType()) {
+        const TupleType *otherTuple = other->AsObjectType()->AsTupleType();
+        if (kind_ == otherTuple->Kind() && desc_->properties.size() == otherTuple->Properties().size()) {
+            const auto &otherProperties = otherTuple->Properties();
+            for (size_t i = 0; i < desc_->properties.size(); i++) {
+                binder::LocalVariable *targetProp = desc_->properties[i];
+                binder::LocalVariable *sourceProp = otherProperties[i];
+
+                if (targetProp->Flags() != sourceProp->Flags()) {
+                    relation->Result(false);
+                    return;
+                }
+
+                relation->IsIdenticalTo(targetProp->TsType(), sourceProp->TsType());
+
+                if (!relation->IsTrue()) {
+                    return;
+                }
+            }
+            relation->Result(true);
+        }
+    }
+}
+
+void TupleType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (!source->IsObjectType() || !source->AsObjectType()->IsTupleType()) {
+        relation->Result(false);
+        return;
+    }
+
+    const TupleType *sourceTuple = source->AsObjectType()->AsTupleType();
+    if (FixedLength() < sourceTuple->MinLength()) {
+        relation->Result(false);
+        return;
+    }
+
+    relation->Result(true);
+
+    const auto &sourceProperties = sourceTuple->Properties();
+    for (size_t i = 0; i < desc_->properties.size(); i++) {
+        auto *targetProp = desc_->properties[i];
+
+        if (i < sourceProperties.size()) {
+            if (!targetProp->HasFlag(binder::VariableFlags::OPTIONAL) &&
+                sourceProperties[i]->HasFlag(binder::VariableFlags::OPTIONAL)) {
+                relation->Result(false);
+                return;
+            }
+
+            Type *targetPropType = targetProp->TsType();
+            Type *sourcePropType = sourceProperties[i]->TsType();
+            if (!relation->IsAssignableTo(sourcePropType, targetPropType)) {
+                return;
+            }
+
+            continue;
+        }
+
+        if (!targetProp->HasFlag(binder::VariableFlags::OPTIONAL)) {
+            relation->Result(false);
+            return;
+        }
+    }
+
+    if (relation->IsTrue()) {
+        AssignIndexInfo(relation, sourceTuple);
+    }
+}
+
+TypeFacts TupleType::GetTypeFacts() const
+{
+    if (desc_->properties.empty()) {
+        return TypeFacts::EMPTY_OBJECT_FACTS;
+    }
+
+    return TypeFacts::OBJECT_FACTS;
+}
+
+Type *TupleType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    ObjectDescriptor *copiedDesc = allocator->New<ObjectDescriptor>();
+
+    desc_->Copy(allocator, copiedDesc, relation, globalTypes);
+
+    NamedTupleMemberPool copiedNamedMemberPool = namedMembers_;
+    TupleElementFlagPool copiedElementFlagPool = elementFlags_;
+
+    return allocator->New<TupleType>(copiedDesc, std::move(copiedElementFlagPool), combinedFlags_, minLength_,
+                                     fixedLength_, readonly_, std::move(copiedNamedMemberPool));
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/tupleType.h b/es2panda/typescript/types/tupleType.h
new file mode 100644
index 0000000000000000000000000000000000000000..241cf60ad5067240a0c5950a20c0ffd661a3278c
--- /dev/null
+++ b/es2panda/typescript/types/tupleType.h
@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TUPLE_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TUPLE_TYPE_H
+
+#include <macros.h>
+
+#include <typescript/types/elementFlags.h>
+#include <typescript/types/objectType.h>
+
+namespace panda::es2panda::checker {
+
+class TupleTypeIterator {
+public:
+    explicit TupleTypeIterator(TupleType *tuple);
+    ~TupleTypeIterator() = default;
+    NO_COPY_SEMANTIC(TupleTypeIterator);
+    NO_MOVE_SEMANTIC(TupleTypeIterator);
+
+    Type *Next();
+    Type *Current();
+    uint32_t Iter() const;
+
+private:
+    TupleType *tupleType_;
+    uint32_t iter_;
+};
+
+using NamedTupleMemberPool = std::unordered_map<binder::LocalVariable *, util::StringView>;
+using TupleElementFlagPool = std::unordered_map<util::StringView, checker::ElementFlags>;
+
+class TupleType : public ObjectType {
+public:
+    TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+              uint32_t minLength, uint32_t fixedLength, bool readonly);
+    TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+              uint32_t minLength, uint32_t fixedLength, bool readonly, NamedTupleMemberPool &&namedMembers);
+    TupleType();
+    ~TupleType() override;
+    NO_COPY_SEMANTIC(TupleType);
+    NO_MOVE_SEMANTIC(TupleType);
+
+    ElementFlags GetElementFlag(const util::StringView &index) const;
+    ElementFlags CombinedFlags() const;
+    uint32_t MinLength() const;
+    uint32_t FixedLength() const;
+    bool HasElementFlag(ElementFlags elementFlag) const;
+    bool HasCombinedFlag(ElementFlags combinedFlag) const;
+    bool IsReadOnly() const;
+    TupleTypeIterator *Iterator();
+    const TupleTypeIterator *Iterator() const;
+    const NamedTupleMemberPool &NamedMembers() const;
+    const util::StringView &FindNamedMemberName(binder::LocalVariable *member) const;
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+private:
+    TupleElementFlagPool elementFlags_ {};
+    ElementFlags combinedFlags_ {};
+    uint32_t minLength_ {};
+    uint32_t fixedLength_ {};
+    NamedTupleMemberPool namedMembers_ {};
+    bool readonly_ {};
+    TupleTypeIterator *iterator_ {nullptr};
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_TUPLE_TYPE_H */
diff --git a/es2panda/typescript/types/type.cpp b/es2panda/typescript/types/type.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b1d8a3647922f326e245f0b4b2967d8124c22a9
--- /dev/null
+++ b/es2panda/typescript/types/type.cpp
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "type.h"
+
+#include <typescript/types/typeFlag.h>
+#include <typescript/types/typeFacts.h>
+#include <typescript/types/typeRelation.h>
+
+namespace panda::es2panda::checker {
+
+Type::Type(TypeFlag flag) : typeFlags_(flag), variable_(nullptr)
+{
+    static uint64_t typeId = 0;
+    id_ = ++typeId;
+}
+
+TypeFlag Type::TypeFlags() const
+{
+    return typeFlags_;
+}
+
+bool Type::HasTypeFlag(TypeFlag typeFlag) const
+{
+    return (typeFlags_ & typeFlag) != 0;
+}
+
+void Type::AddTypeFlag(TypeFlag typeFlag)
+{
+    typeFlags_ |= typeFlag;
+}
+
+void Type::RemoveTypeFlag(TypeFlag typeFlag)
+{
+    typeFlags_ &= ~typeFlag;
+}
+
+uint64_t Type::Id() const
+{
+    return id_;
+}
+
+void Type::ToStringAsSrc(std::stringstream &ss) const
+{
+    ToString(ss);
+}
+
+void Type::SetVariable(binder::Variable *variable)
+{
+    variable_ = variable;
+}
+
+binder::Variable *Type::Variable()
+{
+    return variable_;
+}
+
+const binder::Variable *Type::Variable() const
+{
+    return variable_;
+}
+
+void Type::Identical(TypeRelation *relation, const Type *other) const
+{
+    relation->Result(typeFlags_ == other->TypeFlags());
+}
+
+bool Type::AssignmentSource([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *target) const
+{
+    return false;
+}
+
+void Type::Compare([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *other) const {}
+
+Type *Type::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                        [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/type.h b/es2panda/typescript/types/type.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc9863ffe15f7efa6348c2843eed4a12943ffd6c
--- /dev/null
+++ b/es2panda/typescript/types/type.h
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_H
+
+#include <typescript/types/typeFacts.h>
+#include <typescript/types/typeMapping.h>
+#include <typescript/types/typeRelation.h>
+
+#include <macros.h>
+#include <sstream>
+#include <variant>
+
+namespace panda::es2panda::binder {
+class Variable;
+}  // namespace panda::es2panda::binder
+
+namespace panda::es2panda::checker {
+
+class ObjectDescriptor;
+class GlobalTypesHolder;
+
+#define DECLARE_TYPENAMES(typeFlag, typeName) class typeName;
+TYPE_MAPPING(DECLARE_TYPENAMES)
+#undef DECLARE_TYPENAMES
+
+class Type {
+public:
+    explicit Type(TypeFlag flag);
+    NO_COPY_SEMANTIC(Type);
+    NO_MOVE_SEMANTIC(Type);
+
+    virtual ~Type() = default;
+
+#define TYPE_IS_CHECKS(typeFlag, typeName) \
+    bool Is##typeName() const               \
+    {                                        \
+        return HasTypeFlag(typeFlag);       \
+    }
+    TYPE_MAPPING(TYPE_IS_CHECKS)
+#undef DECLARE_IS_CHECKS
+
+#define TYPE_AS_CASTS(typeFlag, typeName)               \
+    typeName *As##typeName()                            \
+    {                                                     \
+        ASSERT(Is##typeName());                          \
+        return reinterpret_cast<typeName *>(this);       \
+    }                                                     \
+    const typeName *As##typeName() const                \
+    {                                                     \
+        ASSERT(Is##typeName());                          \
+        return reinterpret_cast<const typeName *>(this); \
+    }
+    TYPE_MAPPING(TYPE_AS_CASTS)
+#undef TYPE_AS_CASTS
+
+    TypeFlag TypeFlags() const;
+    bool HasTypeFlag(TypeFlag typeFlag) const;
+    void AddTypeFlag(TypeFlag typeFlag);
+    void RemoveTypeFlag(TypeFlag typeFlag);
+    uint64_t Id() const;
+    void SetVariable(binder::Variable *variable);
+    binder::Variable *Variable();
+    const binder::Variable *Variable() const;
+
+    virtual void ToString(std::stringstream &ss) const = 0;
+    virtual void ToStringAsSrc(std::stringstream &ss) const;
+    virtual TypeFacts GetTypeFacts() const = 0;
+
+    virtual void Identical(TypeRelation *relation, const Type *other) const;
+    virtual void AssignmentTarget(TypeRelation *relation, const Type *source) const = 0;
+    virtual bool AssignmentSource(TypeRelation *relation, const Type *target) const;
+    virtual void Compare(TypeRelation *relation, const Type *other) const;
+
+    virtual Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) = 0;
+
+protected:
+    TypeFlag typeFlags_;
+    binder::Variable *variable_;  // Variable associated with the type if any
+    uint64_t id_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_TYPE_H */
diff --git a/es2panda/typescript/types/typeFacts.h b/es2panda/typescript/types/typeFacts.h
new file mode 100644
index 0000000000000000000000000000000000000000..1988b6a09ce69c96b3daa6275a00f81a245c24fb
--- /dev/null
+++ b/es2panda/typescript/types/typeFacts.h
@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_FACTS_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_FACTS_H
+
+#include <util/enumbitops.h>
+
+namespace panda::es2panda::checker {
+
+enum class TypeFacts {
+    NONE = 0,
+    TYPEOF_EQ_STRING = 1 << 0,        // typeof x === "string"
+    TYPEOF_EQ_NUMBER = 1 << 1,        // typeof x === "number"
+    TYPEOF_EQ_BIGINT = 1 << 2,        // typeof x === "bigint"
+    TYPEOF_EQ_BOOLEAN = 1 << 3,       // typeof x === "boolean"
+    TYPEOF_EQ_SYMBOL = 1 << 4,        // typeof x === "symbol"
+    TYPEOF_EQ_OBJECT = 1 << 5,        // typeof x === "object"
+    TYPEOF_EQ_FUNCTION = 1 << 6,      // typeof x === "function"
+    TYPEOF_EQ_HOST_OBJECT = 1 << 7,   // typeof x === "xxx"
+    TYPEOF_NE_STRING = 1 << 8,        // typeof x !== "string"
+    TYPEOF_NE_NUMBER = 1 << 9,        // typeof x !== "number"
+    TYPEOF_NE_BIGINT = 1 << 10,       // typeof x !== "bigint"
+    TYPEOF_NE_BOOLEAN = 1 << 11,      // typeof x !== "boolean"
+    TYPEOF_NE_SYMBOL = 1 << 12,       // typeof x !== "symbol"
+    TYPEOF_NE_OBJECT = 1 << 13,       // typeof x !== "object"
+    TYPEOF_NE_FUNCTION = 1 << 14,     // typeof x !== "function"
+    TYPEOF_NE_HOST_OBJECT = 1 << 15,  // typeof x !== "xxx"
+    EQ_UNDEFINED = 1 << 16,           // x === undefined
+    EQ_NULL = 1 << 17,                // x === null
+    EQ_UNDEFINED_OR_NULL = 1 << 18,   // x === undefined / x === null
+    NE_UNDEFINED = 1 << 19,           // x !== undefined
+    NE_NULL = 1 << 20,                // x !== null
+    NE_UNDEFINED_OR_NULL = 1 << 21,   // x != undefined / x != null
+    TRUTHY = 1 << 22,                 // x
+    FALSY = 1 << 23,                  // !x
+    ALL = (1 << 24) - 1,
+
+    // Number facts
+    BASE_NUMBER_STRICT_FACTS = TYPEOF_EQ_NUMBER | TYPEOF_NE_STRING | TYPEOF_NE_BIGINT | TYPEOF_NE_BOOLEAN |
+                               TYPEOF_NE_SYMBOL | TYPEOF_NE_OBJECT | TYPEOF_NE_FUNCTION | TYPEOF_NE_HOST_OBJECT |
+                               NE_UNDEFINED | NE_NULL | NE_UNDEFINED_OR_NULL,
+    BASE_NUMBER_FACTS = BASE_NUMBER_STRICT_FACTS | EQ_UNDEFINED | EQ_NULL | EQ_UNDEFINED_OR_NULL | FALSY,
+    NUMBER_FACTS = BASE_NUMBER_FACTS | TRUTHY,
+    ZERO_NUMBER_STRICT_FACTS = BASE_NUMBER_STRICT_FACTS | FALSY,
+    ZERO_NUMBER_FACTS = BASE_NUMBER_FACTS,
+    NON_ZERO_NUMBER_FACTS = BASE_NUMBER_FACTS | TRUTHY,
+
+    // String facts
+    BASE_STRING_STRICT_FACTS = TYPEOF_EQ_STRING | TYPEOF_NE_NUMBER | TYPEOF_NE_BIGINT | TYPEOF_NE_BOOLEAN |
+                               TYPEOF_NE_SYMBOL | TYPEOF_NE_OBJECT | TYPEOF_NE_FUNCTION | TYPEOF_NE_HOST_OBJECT |
+                               NE_UNDEFINED | NE_NULL | NE_UNDEFINED_OR_NULL,
+    BASE_STRING_FACTS = BASE_STRING_STRICT_FACTS | EQ_UNDEFINED | EQ_NULL | EQ_UNDEFINED_OR_NULL | FALSY,
+    STRING_FACTS = BASE_STRING_FACTS | TRUTHY,
+    EMPTY_STRING_STRICT_FACTS = BASE_STRING_STRICT_FACTS | FALSY | TRUTHY,
+    EMPTY_STRING_FACTS = BASE_STRING_FACTS,
+    NON_EMPTY_STRING_FACTS = BASE_STRING_FACTS | TRUTHY,
+
+    // Bigint facts
+    BASE_BIGINT_STRICT_FACTS = TYPEOF_EQ_BIGINT | TYPEOF_NE_STRING | TYPEOF_NE_NUMBER | TYPEOF_NE_BOOLEAN |
+                               TYPEOF_NE_SYMBOL | TYPEOF_NE_OBJECT | TYPEOF_NE_FUNCTION | TYPEOF_NE_HOST_OBJECT |
+                               NE_UNDEFINED | NE_NULL | NE_UNDEFINED_OR_NULL,
+    BASE_BIGINT_FACTS = BASE_BIGINT_STRICT_FACTS | EQ_UNDEFINED | EQ_NULL | EQ_UNDEFINED_OR_NULL | FALSY,
+    BIGINT_FACTS = BASE_BIGINT_FACTS | TRUTHY,
+    ZERO_BIGINT_STRICT_FACTS = BASE_BIGINT_STRICT_FACTS | FALSY,
+    ZERO_BIGINT_FACTS = BASE_BIGINT_FACTS,
+    NON_ZERO_BIGINT_FACTS = BASE_BIGINT_FACTS | TRUTHY,
+
+    // Boolean facts
+    BASE_BOOLEAN_STRICT_FACTS = TYPEOF_NE_BIGINT | TYPEOF_NE_STRING | TYPEOF_NE_NUMBER | TYPEOF_EQ_BOOLEAN |
+                                TYPEOF_NE_SYMBOL | TYPEOF_NE_OBJECT | TYPEOF_NE_FUNCTION | TYPEOF_NE_HOST_OBJECT |
+                                NE_UNDEFINED | NE_NULL | NE_UNDEFINED_OR_NULL,
+    BASE_BOOLEAN_FACTS = BASE_BOOLEAN_STRICT_FACTS | EQ_UNDEFINED | EQ_NULL | EQ_UNDEFINED_OR_NULL | FALSY,
+    BOOLEAN_FACTS = BASE_BOOLEAN_FACTS | TRUTHY,
+    FALSE_STRICT_FACTS = BASE_BOOLEAN_STRICT_FACTS | FALSY,
+    FALSE_FACTS = BASE_BOOLEAN_FACTS,
+    TRUE_STRICT_FACTS = BASE_BOOLEAN_STRICT_FACTS | TRUTHY,
+    TRUE_FACTS = BASE_BOOLEAN_FACTS | TRUTHY,
+
+    // Object facts
+    OBJECT_STRICT_FACTS = TYPEOF_NE_BIGINT | TYPEOF_NE_STRING | TYPEOF_NE_NUMBER | TYPEOF_NE_BOOLEAN |
+                          TYPEOF_NE_SYMBOL | TYPEOF_EQ_OBJECT | TYPEOF_NE_FUNCTION | TYPEOF_EQ_HOST_OBJECT |
+                          NE_UNDEFINED | NE_NULL | NE_UNDEFINED_OR_NULL | TRUTHY,
+    OBJECT_FACTS = OBJECT_STRICT_FACTS | EQ_UNDEFINED | EQ_NULL | EQ_UNDEFINED_OR_NULL | FALSY,
+    EMPTY_OBJECT_STRICT_FACTS = ALL & ~(EQ_UNDEFINED | EQ_NULL | EQ_UNDEFINED_OR_NULL),
+    EMPTY_OBJECT_FACTS = ALL,
+
+    // Function facts
+    FUNCTION_STRICT_FACTS = TYPEOF_NE_BIGINT | TYPEOF_NE_STRING | TYPEOF_NE_NUMBER | TYPEOF_NE_BOOLEAN |
+                            TYPEOF_NE_SYMBOL | TYPEOF_NE_OBJECT | TYPEOF_EQ_FUNCTION | TYPEOF_EQ_HOST_OBJECT |
+                            NE_UNDEFINED | NE_NULL | NE_UNDEFINED_OR_NULL | TRUTHY,
+    FUNCTION_FACTS = FUNCTION_STRICT_FACTS | EQ_UNDEFINED | EQ_NULL | EQ_UNDEFINED_OR_NULL | FALSY,
+
+    // Undefined facts
+    UNDEFINED_FACTS = TYPEOF_NE_BIGINT | TYPEOF_NE_STRING | TYPEOF_NE_NUMBER | TYPEOF_NE_BOOLEAN | TYPEOF_NE_SYMBOL |
+                      TYPEOF_NE_OBJECT | TYPEOF_NE_FUNCTION | TYPEOF_NE_HOST_OBJECT | EQ_UNDEFINED | NE_NULL |
+                      EQ_UNDEFINED_OR_NULL | FALSY,
+
+    // Null facts
+    NULL_FACTS = TYPEOF_NE_BIGINT | TYPEOF_NE_STRING | TYPEOF_NE_NUMBER | TYPEOF_NE_BOOLEAN | TYPEOF_NE_SYMBOL |
+                 TYPEOF_EQ_OBJECT | TYPEOF_NE_FUNCTION | TYPEOF_NE_HOST_OBJECT | NE_UNDEFINED | EQ_NULL |
+                 EQ_UNDEFINED_OR_NULL | FALSY,
+};
+
+DEFINE_BITOPS(TypeFacts)
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_TYPE_FACTS_H */
diff --git a/es2panda/typescript/types/typeFlag.h b/es2panda/typescript/types/typeFlag.h
new file mode 100644
index 0000000000000000000000000000000000000000..b041bb9180477f8b7bf1269fc170613b13dde39d
--- /dev/null
+++ b/es2panda/typescript/types/typeFlag.h
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_FLAG_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_FLAG_H
+
+#include <util/enumbitops.h>
+
+#include <cinttypes>
+
+namespace panda::es2panda::checker {
+
+enum class TypeFlag : uint64_t {
+    NONE = 0,
+    NUMBER = 1ULL << 0,             // x: number
+    STRING = 1ULL << 1,             // x: string
+    BOOLEAN = 1ULL << 2,            // x: boolean
+    VOID = 1ULL << 3,               // x: void
+    NULL_TYPE = 1ULL << 4,          // x: null
+    UNDEFINED = 1ULL << 5,          // x: undefined
+    UNKNOWN = 1ULL << 6,            // x: unknown
+    NEVER = 1ULL << 7,              // x: never
+    UNION = 1ULL << 8,              // x: a | b
+    OBJECT = 1ULL << 9,             // x: object
+    BIGINT = 1ULL << 10,            // x: bigint
+    BOOLEAN_LITERAL = 1ULL << 11,   // x: true
+    NUMBER_LITERAL = 1ULL << 12,    // x: 10
+    STRING_LITERAL = 1ULL << 13,    // x: "foo"
+    BIGINT_LITERAL = 1ULL << 14,    // x: 10n
+    ENUM = 1ULL << 15,              // enum x
+    ENUM_LITERAL = 1ULL << 16,      // member of enum
+    SYMBOL = 1ULL << 17,            // x: symbol
+    UNIQUE_SYMBOL = 1ULL << 18,     // one of JS unique symbols
+    TYPE_PARAMETER = 1ULL << 19,    // function<x>
+    INTERSECTION = 1ULL << 20,      // x: a & b
+    INDEX = 1ULL << 21,             // keyof x
+    INDEX_ACCESS = 1ULL << 22,      // x[a]
+    CONDITIONAL = 1ULL << 23,       // x extends a ? b : c
+    SUBSTITUTION = 1ULL << 24,      // type parameter substitution
+    TEMPLATE_LITERAL = 1ULL << 25,  // x: `hello ${World}`
+    STRING_MAPPING = 1ULL << 27,    // Uppercase/Lowercase type
+    ANY = 1ULL << 28,               // x: any
+    ARRAY = 1ULL << 29,             // x: number[]
+    FUNCTION = 1ULL << 30,          // x: (a) => b
+    NON_PRIMITIVE = 1ULL << 31,     // x: object
+    RELATION_CHECKED = 1ULL << 32,
+    TYPE_REFERENCE = 1ULL << 33,
+    COMPUTED_TYPE_LITERAL_NAME = STRING_LITERAL | NUMBER_LITERAL | ENUM,
+    COMPUTED_NAME = COMPUTED_TYPE_LITERAL_NAME | STRING | NUMBER | ANY | SYMBOL,
+    ANY_OR_UNKNOWN = ANY | UNKNOWN,
+    ANY_OR_VOID = ANY | VOID,
+    NULLABLE = UNDEFINED | NULL_TYPE,
+    ANY_OR_NULLABLE = ANY | NULLABLE,
+    LITERAL = NUMBER_LITERAL | BOOLEAN_LITERAL | STRING_LITERAL | BIGINT_LITERAL,
+    NUMBER_LIKE = NUMBER | NUMBER_LITERAL,
+    NUMBER_LIKE_ENUM = NUMBER_LIKE | ENUM,
+    STRING_LIKE = STRING | STRING_LITERAL,
+    BOOLEAN_LIKE = BOOLEAN | BOOLEAN_LITERAL,
+    BIGINT_LIKE = BIGINT | BIGINT_LITERAL,
+    VOID_LIKE = VOID | UNDEFINED,
+    NUMBER_OR_ANY = NUMBER | ANY,
+    PRIMITIVE = STRING | NUMBER | BIGINT | BOOLEAN | ENUM | ENUM_LITERAL | SYMBOL | VOID | UNDEFINED | NULL_TYPE |
+                LITERAL | UNIQUE_SYMBOL,
+    PRIMITIVE_OR_ANY = PRIMITIVE | ANY,
+    UNION_OR_INTERSECTION = UNION | INTERSECTION,
+    DEFINITELY_FALSY =
+        STRING_LITERAL | NUMBER_LITERAL | BOOLEAN_LITERAL | BIGINT_LITERAL | VOID | UNDEFINED | NULL_TYPE,
+    POSSIBLY_FALSY = DEFINITELY_FALSY | STRING | NUMBER | BOOLEAN | BIGINT,
+    VALID_ARITHMETIC_TYPE = ANY | NUMBER_LIKE | BIGINT_LIKE | ENUM,
+    UNIT = LITERAL | UNIQUE_SYMBOL | NULLABLE,
+};
+
+DEFINE_BITOPS(TypeFlag)
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_TYPE_FLAG_H */
diff --git a/es2panda/typescript/types/typeMapping.h b/es2panda/typescript/types/typeMapping.h
new file mode 100644
index 0000000000000000000000000000000000000000..85383ee2ae894b89901ceec217cea3f08dd4c0e1
--- /dev/null
+++ b/es2panda/typescript/types/typeMapping.h
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPE_MAPPING_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPE_MAPPING_H
+
+#include "typeFlag.h"
+
+#define TYPE_MAPPING(_)                              \
+    _(TypeFlag::ARRAY, ArrayType)                    \
+    _(TypeFlag::ANY, AnyType)                        \
+    _(TypeFlag::BIGINT_LITERAL, BigintLiteralType)   \
+    _(TypeFlag::NUMBER, NumberType)                  \
+    _(TypeFlag::STRING, StringType)                  \
+    _(TypeFlag::BOOLEAN, BooleanType)                \
+    _(TypeFlag::VOID, VoidType)                      \
+    _(TypeFlag::NULL_TYPE, NullType)                 \
+    _(TypeFlag::UNDEFINED, UndefinedType)            \
+    _(TypeFlag::UNKNOWN, UnknownType)                \
+    _(TypeFlag::NEVER, NeverType)                    \
+    _(TypeFlag::UNION, UnionType)                    \
+    _(TypeFlag::OBJECT, ObjectType)                  \
+    _(TypeFlag::BIGINT, BigintType)                  \
+    _(TypeFlag::BOOLEAN_LITERAL, BooleanLiteralType) \
+    _(TypeFlag::NUMBER_LITERAL, NumberLiteralType)   \
+    _(TypeFlag::STRING_LITERAL, StringLiteralType)   \
+    _(TypeFlag::ENUM, EnumType)                      \
+    _(TypeFlag::ENUM_LITERAL, EnumLiteralType)       \
+    _(TypeFlag::TYPE_PARAMETER, TypeParameter)       \
+    _(TypeFlag::TYPE_REFERENCE, TypeReference)       \
+    _(TypeFlag::NON_PRIMITIVE, NonPrimitiveType)
+
+#define OBJECT_TYPE_MAPPING(_)                      \
+    _(ObjectType::ObjectTypeKind::FUNCTION, FunctionType)     \
+    _(ObjectType::ObjectTypeKind::TUPLE, TupleType)           \
+    _(ObjectType::ObjectTypeKind::LITERAL, ObjectLiteralType) \
+    _(ObjectType::ObjectTypeKind::INTERFACE, InterfaceType)
+
+#endif /* TYPE_MAPPING_H */
diff --git a/es2panda/typescript/types/typeParameter.cpp b/es2panda/typescript/types/typeParameter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..de308178c6211cc3369d2fa2a1ef826c643219a5
--- /dev/null
+++ b/es2panda/typescript/types/typeParameter.cpp
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "typeParameter.h"
+
+namespace panda::es2panda::checker {
+
+TypeParameter::TypeParameter(Type *constraint, Type *defaultType)
+    : Type(TypeFlag::TYPE_PARAMETER), constraint_(constraint), default_(defaultType)
+{
+}
+
+const Type *TypeParameter::ConstraintType() const
+{
+    return constraint_;
+}
+
+Type *TypeParameter::DefaultType()
+{
+    return default_;
+}
+
+Type **TypeParameter::DefaultTypeRef()
+{
+    return &default_;
+}
+
+void TypeParameter::SetDefaultType(Type *type)
+{
+    default_ = type;
+}
+
+void TypeParameter::ToString([[maybe_unused]] std::stringstream &ss) const
+{
+    UNREACHABLE();
+}
+
+void TypeParameter::Identical([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *other) const
+{
+    UNREACHABLE();
+}
+
+void TypeParameter::AssignmentTarget([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *source) const
+{
+    UNREACHABLE();
+}
+
+TypeFacts TypeParameter::GetTypeFacts() const
+{
+    UNREACHABLE();
+    return TypeFacts::NONE;
+}
+
+Type *TypeParameter::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                                 [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    UNREACHABLE();
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/typeParameter.h b/es2panda/typescript/types/typeParameter.h
new file mode 100644
index 0000000000000000000000000000000000000000..7462e2508cbc26c505f51b5987b636020cc53d3a
--- /dev/null
+++ b/es2panda/typescript/types/typeParameter.h
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_PARAMETER_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_PARAMETER_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class TypeParameter : public Type {
+public:
+    TypeParameter(Type *constraint, Type *defaultType);
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+    const Type *ConstraintType() const;
+    Type *DefaultType();
+    Type **DefaultTypeRef();
+    void SetDefaultType(Type *type);
+
+private:
+    Type *constraint_;
+    Type *default_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_UNDEFINED_TYPE_H */
diff --git a/es2panda/typescript/types/typeReference.cpp b/es2panda/typescript/types/typeReference.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dc693438a2881d52f331414d69a9d151a1dce19b
--- /dev/null
+++ b/es2panda/typescript/types/typeReference.cpp
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "typeReference.h"
+
+namespace panda::es2panda::checker {
+
+TypeReference::TypeReference(Type **ref) : Type(TypeFlag::TYPE_REFERENCE), ref_(ref) {}
+
+Type *TypeReference::Ref()
+{
+    return (*ref_);
+}
+
+const Type *TypeReference::Ref() const
+{
+    return (*ref_);
+}
+
+void TypeReference::ToString(std::stringstream &ss) const
+{
+    if (*ref_) {
+        (*ref_)->ToString(ss);
+    }
+}
+
+void TypeReference::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (*ref_) {
+        (*ref_)->Identical(relation, other);
+    }
+}
+
+void TypeReference::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    if (*ref_) {
+        (*ref_)->AssignmentTarget(relation, source->IsTypeReference() ? source->AsTypeReference()->Ref() : source);
+    }
+}
+
+TypeFacts TypeReference::GetTypeFacts() const
+{
+    if (*ref_) {
+        return (*ref_)->GetTypeFacts();
+    }
+
+    return TypeFacts::NONE;
+}
+
+Type *TypeReference::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    if (*ref_) {
+        return (*ref_)->Instantiate(allocator, relation, globalTypes);
+    }
+
+    UNREACHABLE();
+    return nullptr;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/typeReference.h b/es2panda/typescript/types/typeReference.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f2876203114cdca88cefa11cd429923069864a4
--- /dev/null
+++ b/es2panda/typescript/types/typeReference.h
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_REFERENCE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_REFERENCE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class TypeReference : public Type {
+public:
+    explicit TypeReference(Type **ref);
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+    Type *Ref();
+    const Type *Ref() const;
+
+private:
+    Type **ref_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_REFERENCE_H */
diff --git a/es2panda/typescript/types/typeRelation.cpp b/es2panda/typescript/types/typeRelation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f9d638e7152cbe61fe8b6d6b9f69b26b9523f1a
--- /dev/null
+++ b/es2panda/typescript/types/typeRelation.cpp
@@ -0,0 +1,163 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "typeRelation.h"
+
+#include <typescript/checker.h>
+#include <typescript/types/indexInfo.h>
+#include <typescript/types/signature.h>
+
+namespace panda::es2panda::checker {
+
+const Type *AsSrc::GetType() const
+{
+    return type_;
+}
+
+TypeRelation::TypeRelation(Checker *checker) : checker_(checker), result_(RelationResult::FALSE) {}
+
+bool TypeRelation::IsTrue() const
+{
+    return result_ == RelationResult::TRUE;
+}
+
+const Checker *TypeRelation::GetChecker() const
+{
+    return checker_;
+}
+
+RelationResult TypeRelation::CacheLookup(const Type *source, const Type *target, const RelationHolder &holder,
+                                         RelationType type) const
+{
+    if (result_ == RelationResult::CACHE_MISS) {
+        return result_;
+    }
+
+    RelationKey relationKey {source->Id(), target->Id()};
+    auto res = holder.cached.find(relationKey);
+    if (res == holder.cached.end()) {
+        return RelationResult::CACHE_MISS;
+    }
+
+    if (res->second.type >= type && res->second.result == RelationResult::TRUE) {
+        return RelationResult::TRUE;
+    }
+
+    if (res->second.type <= type && res->second.result == RelationResult::FALSE) {
+        return RelationResult::FALSE;
+    }
+
+    return RelationResult::CACHE_MISS;
+}
+
+bool TypeRelation::IsIdenticalTo(const Type *source, const Type *target)
+{
+    if (source == target) {
+        Result(true);
+        return true;
+    }
+
+    result_ = CacheLookup(source, target, checker_->IdenticalResults(), RelationType::IDENTICAL);
+    if (result_ == RelationResult::CACHE_MISS) {
+        result_ = RelationResult::FALSE;
+        target->Identical(this, source);
+        checker_->IdenticalResults().cached.insert({{source->Id(), target->Id()}, {result_, RelationType::IDENTICAL}});
+    }
+
+    return result_ == RelationResult::TRUE;
+}
+
+bool TypeRelation::IsIdenticalTo(const Signature *source, const Signature *target)
+{
+    if (source == target) {
+        Result(true);
+        return true;
+    }
+
+    result_ = RelationResult::FALSE;
+    target->Identical(this, source);
+
+    return result_ == RelationResult::TRUE;
+}
+
+bool TypeRelation::IsIdenticalTo(const IndexInfo *source, const IndexInfo *target)
+{
+    if (source == target) {
+        Result(true);
+        return true;
+    }
+
+    result_ = RelationResult::FALSE;
+    target->Identical(this, source);
+
+    return result_ == RelationResult::TRUE;
+}
+
+bool TypeRelation::IsAssignableTo(const Type *source, const Type *target)
+{
+    result_ = CacheLookup(source, target, checker_->AssignableResults(), RelationType::ASSIGNABLE);
+    if (result_ == RelationResult::CACHE_MISS) {
+        if (IsIdenticalTo(source, target)) {
+            return true;
+        }
+
+        result_ = RelationResult::FALSE;
+
+        if (!source->AssignmentSource(this, target)) {
+            target->AssignmentTarget(this, source);
+        }
+
+        checker_->AssignableResults().cached.insert(
+            {{source->Id(), target->Id()}, {result_, RelationType::ASSIGNABLE}});
+    }
+
+    return result_ == RelationResult::TRUE;
+}
+
+bool TypeRelation::IsComparableTo(const Type *source, const Type *target)
+{
+    result_ = CacheLookup(source, target, checker_->ComparableResults(), RelationType::COMPARABLE);
+
+    if (result_ == RelationResult::CACHE_MISS) {
+        if (IsAssignableTo(source, target)) {
+            return true;
+        }
+
+        result_ = RelationResult::FALSE;
+        target->Compare(this, source);
+        checker_->ComparableResults().cached.insert(
+            {{source->Id(), target->Id()}, {result_, RelationType::COMPARABLE}});
+    }
+
+    return result_ == RelationResult::TRUE;
+}
+
+void TypeRelation::RaiseError(const std::string &errMsg, const lexer::SourcePosition &loc) const
+{
+    checker_->ThrowTypeError(errMsg, loc);
+}
+
+void TypeRelation::RaiseError(std::initializer_list<TypeErrorMessageElement> list,
+                              const lexer::SourcePosition &loc) const
+{
+    checker_->ThrowTypeError(list, loc);
+}
+
+void TypeRelation::Result(bool res)
+{
+    result_ = res ? RelationResult::TRUE : RelationResult::FALSE;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/typeRelation.h b/es2panda/typescript/types/typeRelation.h
new file mode 100644
index 0000000000000000000000000000000000000000..27bc93180bd8746f0dffe02d55cd6633ec1775ce
--- /dev/null
+++ b/es2panda/typescript/types/typeRelation.h
@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_RELATION_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_TYPE_RELATION_H
+
+#include <lexer/token/sourceLocation.h>
+#include <lexer/token/tokenType.h>
+#include <macros.h>
+#include <util/ustring.h>
+
+#include <unordered_map>
+#include <variant>
+
+namespace panda::es2panda::checker {
+
+class Signature;
+class IndexInfo;
+class Type;
+class Checker;
+
+enum class RelationResult { TRUE, FALSE, UNKNOWN, MAYBE, CACHE_MISS };
+
+enum class RelationType { COMPARABLE, ASSIGNABLE, IDENTICAL };
+
+class RelationKey {
+public:
+    uint64_t sourceId;
+    uint64_t targetId;
+};
+
+class RelationKeyHasher {
+public:
+    size_t operator()(const RelationKey &key) const noexcept
+    {
+        return static_cast<size_t>(key.sourceId ^ key.targetId);
+    }
+};
+
+class RelationKeyComparator {
+public:
+    bool operator()(const RelationKey &lhs, const RelationKey &rhs) const
+    {
+        return lhs.sourceId == rhs.sourceId && lhs.targetId == rhs.targetId;
+    }
+};
+
+class RealtionEntry {
+public:
+    RelationResult result;
+    RelationType type;
+};
+
+using RelationMap = std::unordered_map<RelationKey, RealtionEntry, RelationKeyHasher, RelationKeyComparator>;
+
+class RelationHolder {
+public:
+    RelationMap cached;
+    RelationType type {};
+};
+
+class AsSrc {
+public:
+    explicit AsSrc(const Type *type) : type_(const_cast<Type *>(type)) {}
+
+    const Type *GetType() const;
+
+private:
+    Type *type_;
+};
+
+using TypeErrorMessageElement = std::variant<const Type *, AsSrc, char *, util::StringView, lexer::TokenType, size_t>;
+
+class TypeRelation {
+public:
+    explicit TypeRelation(Checker *checker);
+
+    bool IsIdenticalTo(const Type *source, const Type *target);
+    bool IsIdenticalTo(const Signature *source, const Signature *target);
+    bool IsIdenticalTo(const IndexInfo *source, const IndexInfo *target);
+    bool IsAssignableTo(const Type *source, const Type *target);
+    bool IsComparableTo(const Type *source, const Type *target);
+    void RaiseError(const std::string &errMsg, const lexer::SourcePosition &loc) const;
+    void RaiseError(std::initializer_list<TypeErrorMessageElement> list, const lexer::SourcePosition &loc) const;
+
+    void Result(bool res);
+    const Checker *GetChecker() const;
+    bool IsTrue() const;
+
+private:
+    RelationResult CacheLookup(const Type *source, const Type *target, const RelationHolder &holder,
+                               RelationType type) const;
+
+    Checker *checker_;
+    RelationResult result_;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_TYPE_RELATION_H */
diff --git a/es2panda/typescript/types/types.h b/es2panda/typescript/types/types.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b3d9810067b7606d298e2e23db021488b202cf8
--- /dev/null
+++ b/es2panda/typescript/types/types.h
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_H
+
+#include "anyType.h"
+#include "arrayType.h"
+#include "bigintLiteralType.h"
+#include "bigintType.h"
+#include "booleanLiteralType.h"
+#include "booleanType.h"
+#include "constructorType.h"
+#include "enumLiteralType.h"
+#include "enumType.h"
+#include "functionType.h"
+#include "interfaceType.h"
+#include "neverType.h"
+#include "nonPrimitiveType.h"
+#include "nullType.h"
+#include "numberLiteralType.h"
+#include "numberType.h"
+#include "objectLiteralType.h"
+#include "objectType.h"
+#include "stringLiteralType.h"
+#include "stringType.h"
+#include "tupleType.h"
+#include "undefinedType.h"
+#include "unionType.h"
+#include "unknownType.h"
+#include "voidType.h"
+#include "indexInfo.h"
+#include "signature.h"
+#include "typeParameter.h"
+#include "typeReference.h"
+
+#endif /* TYPES_H */
diff --git a/es2panda/typescript/types/undefinedType.cpp b/es2panda/typescript/types/undefinedType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bb34e2f1541d635c4aea72f91eec145598bd64ac
--- /dev/null
+++ b/es2panda/typescript/types/undefinedType.cpp
@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "undefinedType.h"
+
+namespace panda::es2panda::checker {
+
+UndefinedType::UndefinedType() : Type(TypeFlag::UNDEFINED) {}
+
+void UndefinedType::ToString(std::stringstream &ss) const
+{
+    ss << "undefined";
+}
+
+void UndefinedType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsUndefinedType()) {
+        relation->Result(true);
+    }
+}
+
+bool UndefinedType::AssignmentSource(TypeRelation *relation, [[maybe_unused]] const Type *target) const
+{
+    relation->Result(!target->IsNeverType());
+    return relation->IsTrue();
+}
+
+void UndefinedType::AssignmentTarget([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *source) const
+{
+}
+
+TypeFacts UndefinedType::GetTypeFacts() const
+{
+    return TypeFacts::UNDEFINED_FACTS;
+}
+
+Type *UndefinedType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                                 [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/undefinedType.h b/es2panda/typescript/types/undefinedType.h
new file mode 100644
index 0000000000000000000000000000000000000000..449bbf3cf3effce39d37dbab668e836bf8a2ecdf
--- /dev/null
+++ b/es2panda/typescript/types/undefinedType.h
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_UNDEFINED_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_UNDEFINED_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class UndefinedType : public Type {
+public:
+    UndefinedType();
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    bool AssignmentSource(TypeRelation *relation, const Type *target) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_UNDEFINED_TYPE_H */
diff --git a/es2panda/typescript/types/unionType.cpp b/es2panda/typescript/types/unionType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..54211b592e8b72c5426af90bb21e1a6c981dd30f
--- /dev/null
+++ b/es2panda/typescript/types/unionType.cpp
@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "unionType.h"
+#include <algorithm>
+
+#include <typescript/types/globalTypesHolder.h>
+
+namespace panda::es2panda::checker {
+
+UnionType::UnionType(std::vector<Type *> &&constituentTypes)
+    : Type(TypeFlag::UNION), constituentTypes_(std::move(constituentTypes))
+{
+    for (auto *it : constituentTypes_) {
+        AddConstituentFlag(it->TypeFlags());
+    }
+}
+
+UnionType::UnionType(std::initializer_list<Type *> types) : Type(TypeFlag::UNION)
+{
+    for (auto *it : types) {
+        constituentTypes_.push_back(it);
+        AddConstituentFlag(it->TypeFlags());
+    }
+}
+
+const std::vector<Type *> &UnionType::ConstituentTypes() const
+{
+    return constituentTypes_;
+}
+
+std::vector<Type *> &UnionType::ConstituentTypes()
+{
+    return constituentTypes_;
+}
+
+void UnionType::AddConstituentType(Type *type, TypeRelation *relation)
+{
+    if ((HasConstituentFlag(TypeFlag::NUMBER) && type->IsNumberLiteralType()) ||
+        (HasConstituentFlag(TypeFlag::STRING) && type->IsStringLiteralType()) ||
+        (HasConstituentFlag(TypeFlag::BIGINT) && type->IsBigintLiteralType()) ||
+        (HasConstituentFlag(TypeFlag::BOOLEAN) && type->IsBooleanLiteralType())) {
+        return;
+    }
+
+    for (auto *it : constituentTypes_) {
+        if (relation->IsIdenticalTo(it, type)) {
+            return;
+        }
+    }
+
+    AddConstituentFlag(type->TypeFlags());
+    constituentTypes_.push_back(type);
+}
+
+void UnionType::AddConstituentFlag(TypeFlag flag)
+{
+    constituentFlags_ |= flag;
+}
+
+void UnionType::RemoveConstituentFlag(TypeFlag flag)
+{
+    constituentFlags_ &= ~flag;
+}
+
+bool UnionType::HasConstituentFlag(TypeFlag flag) const
+{
+    return (constituentFlags_ & flag) != 0;
+}
+
+void UnionType::ToString(std::stringstream &ss) const
+{
+    for (auto it = constituentTypes_.begin(); it != constituentTypes_.end(); it++) {
+        (*it)->ToString(ss);
+        if (std::next(it) != constituentTypes_.end()) {
+            ss << " | ";
+        }
+    }
+}
+
+bool UnionType::EachTypeRelatedToSomeType(TypeRelation *relation, const UnionType *source, const UnionType *target)
+{
+    return std::all_of(source->constituentTypes_.begin(), source->constituentTypes_.end(),
+                       [relation, target](const auto *s) { return TypeRelatedToSomeType(relation, s, target); });
+}
+
+bool UnionType::TypeRelatedToSomeType(TypeRelation *relation, const Type *source, const UnionType *target)
+{
+    return std::any_of(target->constituentTypes_.begin(), target->constituentTypes_.end(),
+                       [relation, source](const auto *t) { return relation->IsIdenticalTo(source, t); });
+}
+
+void UnionType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsUnionType()) {
+        if (EachTypeRelatedToSomeType(relation, this, other->AsUnionType()) &&
+            EachTypeRelatedToSomeType(relation, other->AsUnionType(), this)) {
+            relation->Result(true);
+            return;
+        }
+    }
+
+    relation->Result(false);
+}
+
+bool UnionType::AssignmentSource(TypeRelation *relation, const Type *target) const
+{
+    for (auto *it : constituentTypes_) {
+        if (!relation->IsAssignableTo(it, target)) {
+            return false;
+        }
+    }
+
+    relation->Result(true);
+    return true;
+}
+
+void UnionType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+{
+    for (auto *it : constituentTypes_) {
+        if (relation->IsAssignableTo(source, it)) {
+            return;
+        }
+    }
+}
+
+TypeFacts UnionType::GetTypeFacts() const
+{
+    TypeFacts facts = TypeFacts::NONE;
+
+    for (auto *it : constituentTypes_) {
+        facts |= it->GetTypeFacts();
+    }
+
+    return facts;
+}
+
+void UnionType::RemoveDuplicatedTypes(TypeRelation *relation, std::vector<Type *> &constituentTypes)
+{
+    auto compare = constituentTypes.begin();
+
+    while (compare != constituentTypes.end()) {
+        auto it = compare + 1;
+
+        while (it != constituentTypes.end()) {
+            relation->Result(false);
+
+            (*compare)->Identical(relation, *it);
+
+            if (relation->IsTrue()) {
+                it = constituentTypes.erase(it);
+            } else {
+                it++;
+            }
+        }
+
+        compare = it;
+    }
+}
+
+Type *UnionType::HandleUnionType(UnionType *unionType, GlobalTypesHolder *globalTypesHolder)
+{
+    if (unionType->HasConstituentFlag(TypeFlag::ANY)) {
+        return globalTypesHolder->GlobalAnyType();
+    }
+
+    if (unionType->HasConstituentFlag(TypeFlag::UNKNOWN)) {
+        return globalTypesHolder->GlobalUnknownType();
+    }
+
+    RemoveRedundantLiteralTypesFromUnion(unionType);
+
+    if (unionType->ConstituentTypes().size() == 1) {
+        return unionType->ConstituentTypes()[0];
+    }
+
+    return unionType;
+}
+
+void UnionType::RemoveRedundantLiteralTypesFromUnion(UnionType *type)
+{
+    bool removeNumberLiterals = false;
+    bool removeStringLiterals = false;
+    bool removeBigintLiterals = false;
+    bool removeBooleanLiterals = false;
+
+    if (type->HasConstituentFlag(TypeFlag::NUMBER) && type->HasConstituentFlag(TypeFlag::NUMBER_LITERAL)) {
+        removeNumberLiterals = true;
+    }
+
+    if (type->HasConstituentFlag(TypeFlag::STRING) && type->HasConstituentFlag(TypeFlag::STRING_LITERAL)) {
+        removeStringLiterals = true;
+    }
+
+    if (type->HasConstituentFlag(TypeFlag::BIGINT) && type->HasConstituentFlag(TypeFlag::BIGINT_LITERAL)) {
+        removeBigintLiterals = true;
+    }
+
+    if (type->HasConstituentFlag(TypeFlag::BOOLEAN) && type->HasConstituentFlag(TypeFlag::BOOLEAN_LITERAL)) {
+        removeBooleanLiterals = true;
+    }
+
+    std::vector<Type *> &constituentTypes = type->ConstituentTypes();
+    /* TODO(dbatyai): use std::erase_if */
+    auto it = constituentTypes.begin();
+    while (it != constituentTypes.end()) {
+        if ((removeNumberLiterals && (*it)->IsNumberLiteralType()) ||
+            (removeStringLiterals && (*it)->IsStringLiteralType()) ||
+            (removeBigintLiterals && (*it)->IsBigintLiteralType()) ||
+            (removeBooleanLiterals && (*it)->IsBooleanLiteralType())) {
+            type->RemoveConstituentFlag((*it)->TypeFlags());
+            it = constituentTypes.erase(it);
+            continue;
+        }
+
+        it++;
+    }
+}
+
+Type *UnionType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+{
+    std::vector<Type *> copiedConstituents(constituentTypes_.size());
+
+    for (auto *it : constituentTypes_) {
+        copiedConstituents.push_back(it->Instantiate(allocator, relation, globalTypes));
+    }
+
+    RemoveDuplicatedTypes(relation, copiedConstituents);
+
+    if (copiedConstituents.size() == 1) {
+        return copiedConstituents[0];
+    }
+
+    Type *newUnionType = allocator->New<UnionType>(std::move(copiedConstituents));
+
+    return HandleUnionType(newUnionType->AsUnionType(), globalTypes);
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/unionType.h b/es2panda/typescript/types/unionType.h
new file mode 100644
index 0000000000000000000000000000000000000000..64aa72674bcd49e1d422626a6fb82450a0eb9b47
--- /dev/null
+++ b/es2panda/typescript/types/unionType.h
@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_UNION_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_UNION_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class GlobalTypesHolder;
+
+class UnionType : public Type {
+public:
+    explicit UnionType(std::vector<Type *> &&constituentTypes);
+    UnionType(std::initializer_list<Type *> types);
+
+    const std::vector<Type *> &ConstituentTypes() const;
+    std::vector<Type *> &ConstituentTypes();
+    void AddConstituentType(Type *type, TypeRelation *relation);
+    void AddConstituentFlag(TypeFlag flag);
+    void RemoveConstituentFlag(TypeFlag flag);
+    bool HasConstituentFlag(TypeFlag flag) const;
+
+    void ToString(std::stringstream &ss) const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    bool AssignmentSource(TypeRelation *relation, const Type *target) const override;
+    TypeFacts GetTypeFacts() const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+
+    static void RemoveDuplicatedTypes(TypeRelation *relation, std::vector<Type *> &constituentTypes);
+    static Type *HandleUnionType(UnionType *unionType, GlobalTypesHolder *globalTypesHolder);
+    static void RemoveRedundantLiteralTypesFromUnion(UnionType *type);
+
+private:
+    static bool EachTypeRelatedToSomeType(TypeRelation *relation, const UnionType *source, const UnionType *target);
+    static bool TypeRelatedToSomeType(TypeRelation *relation, const Type *source, const UnionType *target);
+
+    std::vector<Type *> constituentTypes_;
+    TypeFlag constituentFlags_ {TypeFlag::NONE};
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_UNION_TYPE_H */
diff --git a/es2panda/typescript/types/unknownType.cpp b/es2panda/typescript/types/unknownType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..43c3414626f3d0e184105015b66b0b11fa272972
--- /dev/null
+++ b/es2panda/typescript/types/unknownType.cpp
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "unknownType.h"
+
+namespace panda::es2panda::checker {
+
+// Unknown Type
+UnknownType::UnknownType() : Type(TypeFlag::UNKNOWN) {}
+
+void UnknownType::ToString(std::stringstream &ss) const
+{
+    ss << "unknown";
+}
+
+TypeFacts UnknownType::GetTypeFacts() const
+{
+    return TypeFacts::ALL;
+}
+
+void UnknownType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsUnknownType()) {
+        relation->Result(true);
+    }
+}
+
+void UnknownType::AssignmentTarget([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *source) const
+{
+    relation->Result(true);
+}
+
+Type *UnknownType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                               [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/unknownType.h b/es2panda/typescript/types/unknownType.h
new file mode 100644
index 0000000000000000000000000000000000000000..813fa963eeeae95772dd062bb75f3e784c9ba778
--- /dev/null
+++ b/es2panda/typescript/types/unknownType.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_UNKNOWN_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_UNKNOWN_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class UnknownType : public Type {
+public:
+    UnknownType();
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_UNKNOWN_TYPE_H */
diff --git a/es2panda/typescript/types/voidType.cpp b/es2panda/typescript/types/voidType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..19aaf43f81f6b4f8cecff6502fb9a3c83e3df94d
--- /dev/null
+++ b/es2panda/typescript/types/voidType.cpp
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "voidType.h"
+
+namespace panda::es2panda::checker {
+
+VoidType::VoidType() : Type(TypeFlag::VOID) {}
+
+void VoidType::ToString(std::stringstream &ss) const
+{
+    ss << "void";
+}
+
+TypeFacts VoidType::GetTypeFacts() const
+{
+    return TypeFacts::UNDEFINED_FACTS;
+}
+
+void VoidType::Identical(TypeRelation *relation, const Type *other) const
+{
+    if (other->IsVoidType()) {
+        relation->Result(true);
+    }
+}
+
+void VoidType::AssignmentTarget([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *source) const {}
+
+Type *VoidType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                            [[maybe_unused]] GlobalTypesHolder *globalTypes)
+{
+    return this;
+}
+
+}  // namespace panda::es2panda::checker
diff --git a/es2panda/typescript/types/voidType.h b/es2panda/typescript/types/voidType.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf0a5201330f827a7369c626d3a235f531fd90eb
--- /dev/null
+++ b/es2panda/typescript/types/voidType.h
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_COMPILER_TYPESCRIPT_TYPES_VOID_TYPE_H
+#define ES2PANDA_COMPILER_TYPESCRIPT_TYPES_VOID_TYPE_H
+
+#include "type.h"
+
+namespace panda::es2panda::checker {
+
+class VoidType : public Type {
+public:
+    VoidType();
+
+    void ToString(std::stringstream &ss) const override;
+    TypeFacts GetTypeFacts() const override;
+    void Identical(TypeRelation *relation, const Type *other) const override;
+    void AssignmentTarget(TypeRelation *relation, const Type *source) const override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+};
+
+}  // namespace panda::es2panda::checker
+
+#endif /* TYPESCRIPT_TYPES_VOID_TYPE_H */
diff --git a/es2panda/util/bitset.cpp b/es2panda/util/bitset.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fca9a34d5352110354c68d221713e44bd09caede
--- /dev/null
+++ b/es2panda/util/bitset.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bitset.h"
+#include "securec.h"
+
+#include <macros.h>
+
+#include <cstring>
+#include <utility>
+
+namespace panda::es2panda::util {
+BitSet::BitSet(size_t size) : size_(size)
+{
+    size_t dataSize = DataSize();
+    data_ = new uint8_t[dataSize];
+    memset_s(data_, dataSize, 0, dataSize);
+}
+
+BitSet::~BitSet()
+{
+    delete[] data_;
+}
+
+size_t BitSet::DataSize() const noexcept
+{
+    return (size_ >> shiftOffset) + 1;
+}
+
+void BitSet::Clear(bool value) noexcept
+{
+    memset_s(data_, DataSize(), value ? ((sizeof(uint8_t) << 8U) - 1) : 0, DataSize());
+}
+
+void BitSet::Set(size_t pos) noexcept
+{
+    Set(pos, true);
+}
+
+void BitSet::Set(size_t pos, bool value) noexcept
+{
+    ASSERT(pos < size_);
+    size_t idx = pos >> shiftOffset;
+    size_t slot = pos & shiftMask;
+
+    if (value) {
+        data_[idx] |= 1U << slot;
+    } else {
+        data_[idx] &= ~(1U << slot);
+    }
+}
+
+bool BitSet::Test(size_t pos) const noexcept
+{
+    ASSERT(pos < size_);
+    size_t idx = pos >> shiftOffset;
+    size_t slot = pos & shiftMask;
+
+    return (data_[idx] & (1U << slot)) != 0;
+}
+
+}  // namespace panda::es2panda::util
diff --git a/es2panda/util/bitset.h b/es2panda/util/bitset.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad621e04c83e4fcb9bf56121583b91ece301e17d
--- /dev/null
+++ b/es2panda/util/bitset.h
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_UTIL_INCLUDE_BITSET_H
+#define ES2PANDA_UTIL_INCLUDE_BITSET_H
+
+#include <macros.h>
+
+#include <cstddef>
+#include <cstdint>
+
+namespace panda::es2panda::util {
+
+class BitSet {
+public:
+    explicit BitSet(size_t size);
+    NO_COPY_SEMANTIC(BitSet);
+    DEFAULT_MOVE_SEMANTIC(BitSet);
+    ~BitSet();
+
+    void Clear(bool value) noexcept;
+    void Set(size_t pos) noexcept;
+    void Set(size_t pos, bool value) noexcept;
+    bool Test(size_t pos) const noexcept;
+
+private:
+    static const size_t shiftOffset = 3;
+    static const size_t shiftMask = (1U << shiftOffset) - 1;
+    size_t DataSize() const noexcept;
+
+    uint8_t *data_;
+    size_t size_;
+};
+
+}  // namespace panda::es2panda::util
+
+#endif
diff --git a/es2panda/util/enumbitops.h b/es2panda/util/enumbitops.h
new file mode 100644
index 0000000000000000000000000000000000000000..f42426cda410772459cda88bc33496a1d37e59ce
--- /dev/null
+++ b/es2panda/util/enumbitops.h
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_UTIL_INCLUDE_ENUM_BITOPS_H
+#define ES2PANDA_UTIL_INCLUDE_ENUM_BITOPS_H
+
+#include <type_traits>
+
+#define DEFINE_BITOPS(T)                                                          \
+    inline T operator~(T a)                                                       \
+    {                                                                             \
+        using utype = std::underlying_type_t<T>;                                  \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return static_cast<T>(~static_cast<utype>(a));                            \
+    }                                                                             \
+                                                                                  \
+    inline bool operator!(T a)                                                    \
+    {                                                                             \
+        using utype = std::underlying_type_t<T>;                                  \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return (!static_cast<utype>(a));                                          \
+    }                                                                             \
+                                                                                  \
+    inline T operator|(T a, T b)                                                  \
+    {                                                                             \
+        using utype = std::underlying_type_t<T>;                                  \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return static_cast<T>(static_cast<utype>(a) | static_cast<utype>(b));     \
+    }                                                                             \
+                                                                                  \
+    inline std::underlying_type_t<T> operator&(T a, T b)                          \
+    {                                                                             \
+        using utype = std::underlying_type_t<T>;                                  \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return static_cast<utype>(static_cast<utype>(a) & static_cast<utype>(b)); \
+    }                                                                             \
+                                                                                  \
+    inline T operator^(T a, T b)                                                  \
+    {                                                                             \
+        using utype = std::underlying_type_t<T>;                                  \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return static_cast<T>(static_cast<utype>(a) ^ static_cast<utype>(b));     \
+    }                                                                             \
+                                                                                  \
+    inline T &operator|=(T &a, T b)                                               \
+    {                                                                             \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return a = a | b;                                                         \
+    }                                                                             \
+                                                                                  \
+    inline T &operator&=(T &a, T b)                                               \
+    {                                                                             \
+        using utype = std::underlying_type_t<T>;                                  \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return a = static_cast<T>(static_cast<utype>(a) & static_cast<utype>(b)); \
+    }                                                                             \
+                                                                                  \
+    inline T &operator^=(T &a, T b)                                               \
+    {                                                                             \
+        /* NOLINTNEXTLINE(hicpp-signed-bitwise) */                                \
+        return a = a ^ b;                                                         \
+    }
+
+#endif
diff --git a/es2panda/util/helpers.cpp b/es2panda/util/helpers.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5d16303d8a9dad7448281c6eb9c66120d4e75a7c
--- /dev/null
+++ b/es2panda/util/helpers.cpp
@@ -0,0 +1,398 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.Apache.Org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "helpers.h"
+
+#include <ir/base/classDefinition.h>
+#include <ir/base/classProperty.h>
+#include <ir/base/methodDefinition.h>
+#include <ir/base/property.h>
+#include <ir/base/scriptFunction.h>
+#include <ir/base/spreadElement.h>
+#include <ir/expressions/arrayExpression.h>
+#include <ir/expressions/assignmentExpression.h>
+#include <ir/expressions/functionExpression.h>
+#include <ir/expressions/identifier.h>
+#include <ir/expressions/literals/numberLiteral.h>
+#include <ir/expressions/literals/stringLiteral.h>
+#include <ir/expressions/objectExpression.h>
+#include <ir/statements/variableDeclaration.h>
+#include <ir/statements/variableDeclarator.h>
+
+namespace panda::es2panda::util {
+
+// Helpers
+
+bool Helpers::IsGlobalIdentifier(const util::StringView &str)
+{
+    return (str.Is("NaN") || str.Is("undefined") || str.Is("Infinity"));
+}
+
+bool Helpers::ContainSpreadElement(const ArenaVector<ir::Expression *> &args)
+{
+    return std::any_of(args.begin(), args.end(), [](const auto *it) { return it->IsSpreadElement(); });
+}
+
+util::StringView Helpers::LiteralToPropName(const ir::Expression *lit)
+{
+    switch (lit->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            return lit->AsIdentifier()->Name();
+        }
+        case ir::AstNodeType::STRING_LITERAL: {
+            return lit->AsStringLiteral()->Str();
+        }
+        case ir::AstNodeType::NUMBER_LITERAL: {
+            return lit->AsNumberLiteral()->Str();
+        }
+        case ir::AstNodeType::NULL_LITERAL: {
+            return "null";
+        }
+        default: {
+            UNREACHABLE();
+        }
+    }
+}
+
+bool Helpers::IsIndex(double number)
+{
+    if (number >= 0 && number < static_cast<double>(INVALID_INDEX)) {
+        auto intNum = static_cast<uint32_t>(number);
+
+        if (static_cast<double>(intNum) == number) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static bool IsDigit(char c)
+{
+    return (c >= '0' && c <= '9');
+}
+
+int64_t Helpers::GetIndex(const util::StringView &str)
+{
+    const auto &s = str.Utf8();
+
+    if (s.empty() || (*s.begin() == '0' && s.length() > 1)) {
+        return INVALID_INDEX;
+    }
+
+    int64_t value = 0;
+    for (const auto c : s) {
+        if (!IsDigit(c)) {
+            return INVALID_INDEX;
+        }
+
+        constexpr auto MULTIPLIER = 10;
+        value *= MULTIPLIER;
+        value += (c - '0');
+
+        if (value >= INVALID_INDEX) {
+            return INVALID_INDEX;
+        }
+    }
+
+    return value;
+}
+
+std::string Helpers::ToString(double number)
+{
+    std::string str;
+
+    if (Helpers::IsInteger<int32_t>(number)) {
+        str = std::to_string(static_cast<int32_t>(number));
+    } else {
+        str = std::to_string(number);
+    }
+
+    return str;
+}
+
+util::StringView Helpers::ToStringView(ArenaAllocator *allocator, double number)
+{
+    util::UString str(ToString(number), allocator);
+    return str.View();
+}
+
+util::StringView Helpers::ToStringView(ArenaAllocator *allocator, uint32_t number)
+{
+    ASSERT(number <= static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
+    return ToStringView(allocator, static_cast<int32_t>(number));
+}
+
+util::StringView Helpers::ToStringView(ArenaAllocator *allocator, int32_t number)
+{
+    util::UString str(ToString(number), allocator);
+    return str.View();
+}
+
+const ir::ScriptFunction *Helpers::GetContainingConstructor(const ir::AstNode *node)
+{
+    const ir::ScriptFunction *iter = GetContainingFunction(node);
+
+    while (iter != nullptr) {
+        if (iter->IsConstructor()) {
+            return iter;
+        }
+
+        if (!iter->IsArrow()) {
+            return nullptr;
+        }
+
+        iter = GetContainingFunction(iter);
+    }
+
+    return iter;
+}
+
+const ir::ScriptFunction *Helpers::GetContainingConstructor(const ir::ClassProperty *node)
+{
+    for (const auto *parent = node->Parent(); parent != nullptr; parent = parent->Parent()) {
+        if (parent->IsClassDefinition()) {
+            return parent->AsClassDefinition()->Ctor()->Function();
+        }
+    }
+
+    return nullptr;
+}
+
+const ir::ScriptFunction *Helpers::GetContainingFunction(const ir::AstNode *node)
+{
+    for (const auto *parent = node->Parent(); parent != nullptr; parent = parent->Parent()) {
+        if (parent->IsScriptFunction()) {
+            return parent->AsScriptFunction();
+        }
+    }
+
+    return nullptr;
+}
+
+const ir::ClassDefinition *Helpers::GetClassDefiniton(const ir::ScriptFunction *node)
+{
+    ASSERT(node->IsConstructor());
+    ASSERT(node->Parent()->IsFunctionExpression());
+    ASSERT(node->Parent()->Parent()->IsMethodDefinition());
+    ASSERT(node->Parent()->Parent()->Parent()->IsClassDefinition());
+
+    return node->Parent()->Parent()->Parent()->AsClassDefinition();
+}
+
+bool Helpers::IsSpecialPropertyKey(const ir::Expression *expr)
+{
+    if (!expr->IsStringLiteral()) {
+        return false;
+    }
+
+    auto *lit = expr->AsStringLiteral();
+    return lit->Str().Is("prototype") || lit->Str().Is("constructor");
+}
+
+bool Helpers::IsConstantPropertyKey(const ir::Expression *expr, bool isComputed)
+{
+    switch (expr->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            return !isComputed;
+        }
+        case ir::AstNodeType::NUMBER_LITERAL:
+        case ir::AstNodeType::STRING_LITERAL:
+        case ir::AstNodeType::BOOLEAN_LITERAL:
+        case ir::AstNodeType::NULL_LITERAL: {
+            return true;
+        }
+        default:
+            break;
+    }
+
+    return false;
+}
+
+bool Helpers::IsConstantExpr(const ir::Expression *expr)
+{
+    switch (expr->Type()) {
+        case ir::AstNodeType::NUMBER_LITERAL:
+        case ir::AstNodeType::STRING_LITERAL:
+        case ir::AstNodeType::BOOLEAN_LITERAL:
+        case ir::AstNodeType::NULL_LITERAL: {
+            return true;
+        }
+        default:
+            break;
+    }
+
+    return false;
+}
+
+bool Helpers::IsBindingPattern(const ir::AstNode *node)
+{
+    return node->IsArrayPattern() || node->IsObjectPattern();
+}
+
+bool Helpers::IsPattern(const ir::AstNode *node)
+{
+    return node->IsArrayPattern() || node->IsObjectPattern() || node->IsAssignmentPattern();
+}
+
+static void CollectBindingName(const ir::AstNode *node, std::vector<const ir::Identifier *> *bindings)
+{
+    switch (node->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            if (!Helpers::IsGlobalIdentifier(node->AsIdentifier()->Name())) {
+                bindings->push_back(node->AsIdentifier());
+            }
+
+            break;
+        }
+        case ir::AstNodeType::OBJECT_PATTERN: {
+            for (const auto *prop : node->AsObjectPattern()->Properties()) {
+                CollectBindingName(prop, bindings);
+            }
+            break;
+        }
+        case ir::AstNodeType::ARRAY_PATTERN: {
+            for (const auto *element : node->AsArrayPattern()->Elements()) {
+                CollectBindingName(element, bindings);
+            }
+            break;
+        }
+        case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+            CollectBindingName(node->AsAssignmentPattern()->Left(), bindings);
+            break;
+        }
+        case ir::AstNodeType::PROPERTY: {
+            CollectBindingName(node->AsProperty()->Value(), bindings);
+            break;
+        }
+        case ir::AstNodeType::REST_ELEMENT: {
+            CollectBindingName(node->AsRestElement()->Argument(), bindings);
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+std::vector<const ir::Identifier *> Helpers::CollectBindingNames(const ir::AstNode *node)
+{
+    std::vector<const ir::Identifier *> bindings;
+    CollectBindingName(node, &bindings);
+    return bindings;
+}
+
+util::StringView Helpers::FunctionName(const ir::ScriptFunction *func)
+{
+    if (func->Id()) {
+        return func->Id()->Name();
+    }
+
+    if (func->Parent()->IsFunctionDeclaration()) {
+        return "*default*";
+    }
+
+    const ir::AstNode *parent = func->Parent()->Parent();
+
+    if (func->IsConstructor()) {
+        parent = parent->Parent();
+        if (parent->AsClassDefinition()->Ident()) {
+            return parent->AsClassDefinition()->Ident()->Name();
+        }
+
+        parent = parent->Parent()->Parent();
+    }
+
+    switch (parent->Type()) {
+        case ir::AstNodeType::VARIABLE_DECLARATOR: {
+            const ir::VariableDeclarator *varDecl = parent->AsVariableDeclarator();
+
+            if (varDecl->Id()->IsIdentifier()) {
+                return varDecl->Id()->AsIdentifier()->Name();
+            }
+
+            break;
+        }
+        case ir::AstNodeType::METHOD_DEFINITION: {
+            const ir::MethodDefinition *methodDef = parent->AsMethodDefinition();
+
+            if (methodDef->Key()->IsIdentifier()) {
+                return methodDef->Key()->AsIdentifier()->Name();
+            }
+
+            break;
+        }
+        case ir::AstNodeType::ASSIGNMENT_EXPRESSION: {
+            const ir::AssignmentExpression *assignment = parent->AsAssignmentExpression();
+
+            if (assignment->Left()->IsIdentifier()) {
+                return assignment->Left()->AsIdentifier()->Name();
+            }
+
+            break;
+        }
+        case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+            const ir::AssignmentExpression *assignment = parent->AsAssignmentPattern();
+
+            if (assignment->Left()->IsIdentifier()) {
+                return assignment->Left()->AsIdentifier()->Name();
+            }
+
+            break;
+        }
+        case ir::AstNodeType::PROPERTY: {
+            const ir::Property *prop = parent->AsProperty();
+
+            if (prop->Kind() != ir::PropertyKind::PROTO &&
+                Helpers::IsConstantPropertyKey(prop->Key(), prop->IsComputed())) {
+                return Helpers::LiteralToPropName(prop->Key());
+            }
+
+            break;
+        }
+        default:
+            break;
+    }
+
+    return util::StringView();
+}
+
+std::tuple<util::StringView, bool> Helpers::ParamName(ArenaAllocator *allocator, const ir::AstNode *param,
+                                                      uint32_t index)
+{
+    switch (param->Type()) {
+        case ir::AstNodeType::IDENTIFIER: {
+            return {param->AsIdentifier()->Name(), false};
+        }
+        case ir::AstNodeType::ASSIGNMENT_PATTERN: {
+            const auto *lhs = param->AsAssignmentPattern()->Left();
+            if (lhs->IsIdentifier()) {
+                return {param->AsAssignmentPattern()->Left()->AsIdentifier()->Name(), false};
+            }
+            break;
+        }
+        case ir::AstNodeType::REST_ELEMENT: {
+            if (param->AsRestElement()->Argument()->IsIdentifier()) {
+                return {param->AsRestElement()->Argument()->AsIdentifier()->Name(), false};
+            }
+            break;
+        }
+        default:
+            break;
+    }
+
+    return {Helpers::ToStringView(allocator, index), true};
+}
+
+}  // namespace panda::es2panda::util
diff --git a/es2panda/util/helpers.h b/es2panda/util/helpers.h
new file mode 100644
index 0000000000000000000000000000000000000000..095e409ca34e2b30d61de36abc953676ed32d43c
--- /dev/null
+++ b/es2panda/util/helpers.h
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_UTIL_HELPERS_H
+#define ES2PANDA_UTIL_HELPERS_H
+
+#include <binder/variableFlags.h>
+#include <mem/arena_allocator.h>
+#include <util/ustring.h>
+
+#include <cmath>
+
+namespace panda::es2panda::ir {
+class Expression;
+class ScriptFunction;
+class ClassDefinition;
+class ClassProperty;
+class Identifier;
+class AstNode;
+}  // namespace panda::es2panda::ir
+
+namespace panda::es2panda::util {
+
+class Helpers {
+public:
+    Helpers() = delete;
+
+    static bool IsGlobalIdentifier(const util::StringView &str);
+    static bool ContainSpreadElement(const ArenaVector<ir::Expression *> &args);
+    static util::StringView LiteralToPropName(const ir::Expression *lit);
+
+    template <typename T>
+    static bool IsInteger(double number);
+    static bool IsIndex(double number);
+    static int64_t GetIndex(const util::StringView &str);
+
+    static std::string ToString(double number);
+    static util::StringView ToStringView(ArenaAllocator *allocator, double number);
+    static util::StringView ToStringView(ArenaAllocator *allocator, int32_t number);
+    static util::StringView ToStringView(ArenaAllocator *allocator, uint32_t number);
+
+    static const ir::ScriptFunction *GetContainingConstructor(const ir::AstNode *node);
+    static const ir::ScriptFunction *GetContainingConstructor(const ir::ClassProperty *node);
+    static const ir::ScriptFunction *GetContainingFunction(const ir::AstNode *node);
+    static const ir::ClassDefinition *GetClassDefiniton(const ir::ScriptFunction *node);
+    static bool IsSpecialPropertyKey(const ir::Expression *expr);
+    static bool IsConstantPropertyKey(const ir::Expression *expr, bool isComputed);
+    static bool IsConstantExpr(const ir::Expression *expr);
+    static bool IsBindingPattern(const ir::AstNode *node);
+    static bool IsPattern(const ir::AstNode *node);
+    static std::vector<const ir::Identifier *> CollectBindingNames(const ir::AstNode *node);
+    static util::StringView FunctionName(const ir::ScriptFunction *func);
+    static std::tuple<util::StringView, bool> ParamName(ArenaAllocator *allocator, const ir::AstNode *param,
+                                                        uint32_t index);
+
+    static const uint32_t INVALID_INDEX = 4294967295L;
+};
+
+template <typename T>
+bool Helpers::IsInteger(double number)
+{
+    if (std::fabs(number) <= static_cast<double>(std::numeric_limits<T>::max())) {
+        T intNum = static_cast<T>(number);
+
+        if (static_cast<double>(intNum) == number) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+}  // namespace panda::es2panda::util
+
+#endif
diff --git a/es2panda/util/ustring.cpp b/es2panda/util/ustring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc06b9660116d64ac855e4e07122f25a1b5a2182
--- /dev/null
+++ b/es2panda/util/ustring.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ustring.h"
+
+#include <iterator>
+
+namespace panda::es2panda::util {
+
+std::string StringView::Mutf8() const noexcept
+{
+    std::string mutf8;
+    mutf8.reserve(sv_.size());
+
+    Iterator iter(*this);
+
+    while (iter.HasNext()) {
+        Mutf8Encode(&mutf8, iter.Next());
+    }
+
+    return mutf8;
+}
+
+char32_t StringView::DecodeSurrogates(char32_t high, char32_t low)
+{
+    constexpr auto OFFSET = 10;
+    char32_t result = (high - Constants::SURROGATE_HIGH_MIN) << OFFSET;
+    result += low - Constants::SURROGATE_LOW_MAX;
+    result += Constants::CELESTIAL_OFFSET;
+    return result;
+}
+
+std::tuple<char32_t, char32_t> StringView::EncodeSurrogate(char32_t cp)
+{
+    constexpr auto OFFSET = 10;
+    char32_t cu1 = ((cp - Constants::CELESTIAL_OFFSET) >> OFFSET) | Constants::SURROGATE_HIGH_MIN;
+    char32_t cu2 = (cp & Constants::SURROGATE_LOW_MARKER) | Constants::SURROGATE_HIGH_MAX;
+
+    return {cu1, cu2};
+}
+
+void StringView::Iterator::SkipCp()
+{
+    if (!HasNext()) {
+        return;
+    }
+
+    char32_t cu0 = static_cast<uint8_t>(*iter_++);
+
+    if (cu0 < Constants::UTF8_1BYTE_LIMIT) {
+        return;
+    }
+
+    if ((cu0 & Constants::UTF8_3BYTE_HEADER) == Constants::UTF8_2BYTE_HEADER) {
+        iter_ += 1U;
+        return;
+    }
+
+    if ((cu0 & Constants::UTF8_4BYTE_HEADER) == Constants::UTF8_3BYTE_HEADER) {
+        iter_ += 2U;
+        return;
+    }
+
+    if (((cu0 & Constants::UTF8_DECODE_4BYTE_MASK) == Constants::UTF8_4BYTE_HEADER) &&
+        (cu0 <= Constants::UTF8_DECODE_4BYTE_LIMIT)) {
+        iter_ += 3U;
+        return;
+    }
+}
+
+}  // namespace panda::es2panda::util
+
+// NOLINTNEXTLINE(cert-dcl58-cpp)
+namespace std {
+
+ostream &operator<<(ostream &os, const panda::es2panda::util::StringView &us)
+{
+    os << us.Utf8();
+    return os;
+}
+
+}  // namespace std
diff --git a/es2panda/util/ustring.h b/es2panda/util/ustring.h
new file mode 100644
index 0000000000000000000000000000000000000000..1801234961d79bdf1a60ad245dffd650e0e2c007
--- /dev/null
+++ b/es2panda/util/ustring.h
@@ -0,0 +1,476 @@
+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ES2PANDA_UTIL_INCLUDE_USTRING_H
+#define ES2PANDA_UTIL_INCLUDE_USTRING_H
+
+#include <macros.h>
+#include <utils/arena_containers.h>
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <string>
+#include <string_view>
+
+namespace panda::es2panda::util {
+
+class StringView {
+public:
+    explicit StringView() noexcept = default;
+    explicit StringView(const ArenaString *str) noexcept : sv_(*str) {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    StringView(std::string_view sv) noexcept : sv_(sv) {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    StringView(const char *str) noexcept : sv_(str) {}
+    DEFAULT_COPY_SEMANTIC(StringView);
+    DEFAULT_MOVE_SEMANTIC(StringView);
+    ~StringView() = default;
+
+    bool operator==(const StringView &rhs) const noexcept
+    {
+        return sv_ == rhs.sv_;
+    }
+
+    bool operator!=(const StringView &rhs) const noexcept
+    {
+        return sv_ != rhs.sv_;
+    }
+
+    bool operator<(const StringView &rhs) const noexcept
+    {
+        return sv_ < rhs.sv_;
+    }
+
+    bool operator>(const StringView &rhs) const noexcept
+    {
+        return sv_ > rhs.sv_;
+    }
+
+    int Compare(const StringView &other) const noexcept
+    {
+        return sv_.compare(other.sv_);
+    }
+
+    int Compare(const std::string_view &other) const noexcept
+    {
+        return sv_.compare(other);
+    }
+
+    bool Is(const char *str) const noexcept
+    {
+        return sv_ == str;
+    }
+
+    bool Is(const std::string_view &str) const noexcept
+    {
+        return sv_ == str;
+    }
+
+    size_t Length() const noexcept
+    {
+        return sv_.length();
+    }
+
+    bool Empty() const noexcept
+    {
+        return sv_.empty();
+    }
+
+    const std::string_view &Utf8() const noexcept
+    {
+        return sv_;
+    }
+
+    explicit operator std::string() const noexcept
+    {
+        return std::string {sv_};
+    }
+
+    const char *Bytes() const noexcept
+    {
+        return sv_.data();
+    }
+
+    StringView Substr(size_t begin, size_t end) const noexcept
+    {
+        return StringView(std::string_view(sv_.data() + begin, end - begin));
+    }
+
+    static bool IsHighSurrogate(char32_t cp)
+    {
+        return (cp >= Constants::SURROGATE_HIGH_MIN && cp < Constants::SURROGATE_HIGH_MAX);
+    }
+
+    static bool IsLowSurrogate(char32_t cp)
+    {
+        return (cp >= Constants::SURROGATE_LOW_MIN && cp < Constants::SURROGATE_LOW_MAX);
+    }
+
+    std::string Mutf8() const noexcept;
+    static char32_t DecodeSurrogates(char32_t high, char32_t low);
+    static std::tuple<char32_t, char32_t> EncodeSurrogate(char32_t cp);
+
+    template <void encoder(std::string *, char32_t)>
+    std::string EscapeSymbol() const;
+
+    template <typename T>
+    static void Utf8Encode(T *str, char32_t cu);
+    template <typename T>
+    static void Mutf8Encode(T *str, char32_t cu);
+
+    class Iterator {
+    public:
+        static char32_t constexpr INVALID_CP = std::numeric_limits<char32_t>::max();
+
+        explicit Iterator(const StringView &sv) noexcept : sv_(sv.sv_), iter_(sv_.begin()) {}
+        DEFAULT_COPY_SEMANTIC(Iterator);
+        DEFAULT_MOVE_SEMANTIC(Iterator);
+        ~Iterator() = default;
+
+        inline size_t Index() const
+        {
+            return static_cast<size_t>(iter_ - sv_.begin());
+        }
+
+        inline char32_t Next()
+        {
+            return DecodeCP<true>(nullptr);
+        }
+
+        inline char32_t Peek() const
+        {
+            return HasNext() ? *iter_ : INVALID_CP;
+        }
+
+        inline char32_t PeekCp() const
+        {
+            return DecodeCP<false>(nullptr);
+        }
+
+        inline char32_t PeekCp(size_t *cpSize) const
+        {
+            return DecodeCP<false, true>(cpSize);
+        }
+
+        inline void Forward(size_t offset)
+        {
+            iter_ += offset;
+        }
+
+        inline void Backward(size_t offset)
+        {
+            iter_ -= offset;
+        }
+
+        inline void Reset(size_t offset)
+        {
+            iter_ = sv_.begin() + offset;
+        }
+
+        inline void Rewind(std::string_view::const_iterator pos)
+        {
+            iter_ = pos;
+        }
+
+        inline std::string_view::const_iterator Save() const
+        {
+            return iter_;
+        }
+
+        inline bool HasNext() const
+        {
+            return iter_ != sv_.end();
+        }
+
+        void SkipCp();
+
+    private:
+        template <bool moveIter, bool setCpSize = false>
+        char32_t DecodeCP([[maybe_unused]] size_t *cpSize) const;
+
+        std::string_view sv_;
+        mutable std::string_view::const_iterator iter_;
+    };
+
+private:
+    class Constants {
+    public:
+        static constexpr uint16_t UTF8_1BYTE_LIMIT = 0x80;
+        static constexpr uint16_t UTF8_2BYTE_LIMIT = 0x800;
+        static constexpr uint32_t UTF8_3BYTE_LIMIT = 0x10000;
+
+        static constexpr uint16_t UTF8_2BYTE_MASK = 0x1F;
+        static constexpr uint16_t UTF8_3BYTE_MASK = 0x0F;
+        static constexpr uint16_t UTF8_4BYTE_MASK = 0x07;
+
+        static constexpr uint16_t UTF8_DECODE_4BYTE_MASK = 0xf8;
+        static constexpr uint16_t UTF8_DECODE_4BYTE_LIMIT = 0xf4;
+
+        static constexpr uint16_t UTF8_2BYTE_HEADER = 0xC0;
+        static constexpr uint16_t UTF8_3BYTE_HEADER = 0xE0;
+        static constexpr uint16_t UTF8_4BYTE_HEADER = 0xF0;
+
+        static constexpr uint16_t UTF8_2BYTE_SHIFT = 6U;
+        static constexpr uint16_t UTF8_3BYTE_SHIFT = 12U;
+        static constexpr uint16_t UTF8_4BYTE_SHIFT = 18U;
+
+        static constexpr uint16_t UTF8_CONT_MASK = 0x3F;
+        static constexpr uint16_t UTF8_CONT_HEADER = 0x80;
+
+        static constexpr char32_t SURROGATE_HIGH_MIN = 0xD800;
+        static constexpr char32_t SURROGATE_HIGH_MAX = 0xDC00;
+        static constexpr char32_t SURROGATE_LOW_MIN = 0xDC00;
+        static constexpr char32_t SURROGATE_LOW_MAX = 0xE000;
+        static constexpr char32_t SURROGATE_LOW_MARKER = 0x3ff;
+        static constexpr char32_t CELESTIAL_OFFSET = UTF8_3BYTE_LIMIT;
+    };
+
+    friend class Iterator;
+    std::string_view sv_;
+};
+
+class UString {
+public:
+    UString() = default;
+    explicit UString(ArenaAllocator *allocator) : allocator_(allocator) {}
+    explicit UString(const std::string &str, ArenaAllocator *allocator) : UString(allocator)
+    {
+        Alloc();
+        *str_ = str;
+    }
+
+    DEFAULT_COPY_SEMANTIC(UString);
+    DEFAULT_MOVE_SEMANTIC(UString);
+    ~UString() = default;
+
+    util::StringView View() const
+    {
+        if (!str_) {
+            return util::StringView();
+        }
+
+        return util::StringView(str_);
+    }
+
+    void Append(char32_t ch) noexcept
+    {
+        if (!str_) {
+            Alloc();
+        }
+
+        StringView::Utf8Encode<ArenaString>(str_, ch);
+    }
+
+    void Append(const StringView &other) noexcept
+    {
+        if (!str_) {
+            Alloc();
+        }
+
+        *str_ += other.Utf8();
+    }
+
+    void Append(const char *other) noexcept
+    {
+        if (!str_) {
+            Alloc();
+        }
+        *str_ += other;
+    }
+
+private:
+    void Alloc()
+    {
+        str_ = allocator_->New<ArenaString>(allocator_->Adapter());
+    }
+
+protected:
+    ArenaString *str_ {};
+    ArenaAllocator *allocator_ {};
+};
+
+template <bool moveIter, bool setCpSize>
+char32_t StringView::Iterator::DecodeCP([[maybe_unused]] size_t *cpSize) const
+{
+    if (!HasNext()) {
+        return INVALID_CP;
+    }
+
+    const auto *iterNext = iter_;
+
+    char32_t cu0 = static_cast<uint8_t>(*iterNext++);
+    char32_t res {};
+
+    if (cu0 < Constants::UTF8_1BYTE_LIMIT) {
+        res = cu0;
+    } else if ((cu0 & Constants::UTF8_3BYTE_HEADER) == Constants::UTF8_2BYTE_HEADER) {
+        char32_t cu1 = static_cast<uint8_t>(*iterNext++);
+        res = ((cu0 & Constants::UTF8_2BYTE_MASK) << Constants::UTF8_2BYTE_SHIFT) | (cu1 & Constants::UTF8_CONT_MASK);
+    } else if ((cu0 & Constants::UTF8_4BYTE_HEADER) == Constants::UTF8_3BYTE_HEADER) {
+        char32_t cu1 = static_cast<uint8_t>(*iterNext++);
+        char32_t cu2 = static_cast<uint8_t>(*iterNext++);
+        res = ((cu0 & Constants::UTF8_3BYTE_MASK) << Constants::UTF8_3BYTE_SHIFT) |
+              ((cu1 & Constants::UTF8_CONT_MASK) << Constants::UTF8_2BYTE_SHIFT) | (cu2 & Constants::UTF8_CONT_MASK);
+    } else if (((cu0 & Constants::UTF8_DECODE_4BYTE_MASK) == Constants::UTF8_4BYTE_HEADER) &&
+               (cu0 <= Constants::UTF8_DECODE_4BYTE_LIMIT)) {
+        char32_t cu1 = static_cast<uint8_t>(*iterNext++);
+        char32_t cu2 = static_cast<uint8_t>(*iterNext++);
+        char32_t cu3 = static_cast<uint8_t>(*iterNext++);
+        res = ((cu0 & Constants::UTF8_4BYTE_MASK) << Constants::UTF8_4BYTE_SHIFT) |
+              ((cu1 & Constants::UTF8_CONT_MASK) << Constants::UTF8_3BYTE_SHIFT) |
+              ((cu2 & Constants::UTF8_CONT_MASK) << Constants::UTF8_2BYTE_SHIFT) | (cu3 & Constants::UTF8_CONT_MASK);
+    } else {
+        res = INVALID_CP;
+    }
+
+    // NOLINTNEXTLINE(readability-braces-around-statements,bugprone-suspicious-semicolon)
+    if constexpr (moveIter) {
+        iter_ = iterNext;
+        return res;
+    }
+
+    // NOLINTNEXTLINE(readability-braces-around-statements,bugprone-suspicious-semicolon)
+    if constexpr (setCpSize) {
+        *cpSize = iterNext - iter_;
+    }
+
+    return res;
+}
+
+template <void encoder(std::string *, char32_t)>
+std::string StringView::EscapeSymbol() const
+{
+    std::string str;
+    str.reserve(Length());
+
+    Iterator iter(*this);
+
+    while (iter.HasNext()) {
+        auto cp = iter.Next();
+
+        switch (cp) {
+            case '\r': {
+                if (iter.HasNext()) {
+                    iter.Forward(1);
+
+                    if (iter.Peek() != '\n') {
+                        iter.Backward(1);
+                    }
+                }
+
+                [[fallthrough]];
+            }
+            case '\n': {
+                str += "\\n";
+                break;
+            }
+            case '\b': {
+                str += "\\b";
+                break;
+            }
+            case '\t': {
+                str += "\\t";
+                break;
+            }
+            case '\f': {
+                str += "\\f";
+                break;
+            }
+            case '"': {
+                str += "\\\"";
+                break;
+            }
+            case '\\': {
+                str += "\\\\";
+                break;
+            }
+            default: {
+                encoder(&str, cp);
+            }
+        }
+    }
+
+    return str;
+}
+
+template <typename T>
+void StringView::Utf8Encode(T *str, char32_t cu)
+{
+    if (cu < Constants::UTF8_1BYTE_LIMIT) {
+        str->push_back(static_cast<char>(cu));
+    } else if (cu < Constants::UTF8_2BYTE_LIMIT) {
+        str->push_back(static_cast<char>(((cu >> Constants::UTF8_2BYTE_SHIFT) & Constants::UTF8_2BYTE_MASK) |
+                                         Constants::UTF8_2BYTE_HEADER));
+        str->push_back(static_cast<char>((cu & Constants::UTF8_CONT_MASK) | Constants::UTF8_CONT_HEADER));
+    } else if (cu < Constants::UTF8_3BYTE_LIMIT) {
+        str->push_back(static_cast<char>(((cu >> Constants::UTF8_3BYTE_SHIFT) & Constants::UTF8_3BYTE_MASK) |
+                                         Constants::UTF8_3BYTE_HEADER));
+        str->push_back(static_cast<char>(((cu >> Constants::UTF8_2BYTE_SHIFT) & Constants::UTF8_CONT_MASK) |
+                                         Constants::UTF8_CONT_HEADER));
+        str->push_back(static_cast<char>((cu & Constants::UTF8_CONT_MASK) | Constants::UTF8_CONT_HEADER));
+    } else {
+        str->push_back(static_cast<char>(((cu >> Constants::UTF8_4BYTE_SHIFT) & Constants::UTF8_4BYTE_MASK) |
+                                         Constants::UTF8_4BYTE_HEADER));
+        str->push_back(static_cast<char>(((cu >> Constants::UTF8_3BYTE_SHIFT) & Constants::UTF8_CONT_MASK) |
+                                         Constants::UTF8_CONT_HEADER));
+        str->push_back(static_cast<char>(((cu >> Constants::UTF8_2BYTE_SHIFT) & Constants::UTF8_CONT_MASK) |
+                                         Constants::UTF8_CONT_HEADER));
+        str->push_back(static_cast<char>((cu & Constants::UTF8_CONT_MASK) | Constants::UTF8_CONT_HEADER));
+    }
+}
+
+template <typename T>
+void StringView::Mutf8Encode(T *str, char32_t cu)
+{
+    if (cu == 0) {
+        str->push_back(static_cast<char>(Constants::UTF8_2BYTE_HEADER));
+        str->push_back(static_cast<char>(Constants::UTF8_CONT_HEADER));
+    } else if (cu < Constants::UTF8_1BYTE_LIMIT) {
+        str->push_back(static_cast<char>(cu));
+    } else if (cu < Constants::UTF8_2BYTE_LIMIT) {
+        str->push_back(static_cast<char>((cu >> Constants::UTF8_2BYTE_SHIFT) | Constants::UTF8_2BYTE_HEADER));
+        str->push_back(static_cast<char>((cu & Constants::UTF8_CONT_MASK) | Constants::UTF8_CONT_HEADER));
+    } else if (cu < Constants::UTF8_3BYTE_LIMIT) {
+        str->push_back(static_cast<char>((cu >> Constants::UTF8_3BYTE_SHIFT) | Constants::UTF8_3BYTE_HEADER));
+        str->push_back(static_cast<char>(((cu >> Constants::UTF8_2BYTE_SHIFT) & Constants::UTF8_CONT_MASK) |
+                                         Constants::UTF8_CONT_HEADER));
+        str->push_back(static_cast<char>((cu & Constants::UTF8_CONT_MASK) | Constants::UTF8_CONT_HEADER));
+    } else {
+        auto [cu1, cu2] = EncodeSurrogate(cu);
+        Mutf8Encode(str, cu1);
+        Mutf8Encode(str, cu2);
+    }
+}
+
+}  // namespace panda::es2panda::util
+
+// NOLINTNEXTLINE(cert-dcl58-cpp)
+namespace std {
+
+template <>
+// NOLINTNEXTLINE(altera-struct-pack-align)
+struct hash<panda::es2panda::util::StringView> {
+    std::size_t operator()(const panda::es2panda::util::StringView &str) const
+    {
+        return std::hash<std::string_view> {}(str.Utf8());
+    }
+};
+
+ostream &operator<<(ostream &os, const panda::es2panda::util::StringView &us);
+
+}  // namespace std
+
+#endif